#include <chrono>
#include "measure_swc_icas.h"
#include "measure_swc_J3_LANE.h"
#include "measure_swc_vmc.h"
#include "measure_swc_J3_TSR.h"
#include "measure_swc_vmp.h"
#include "measure_swc_aeb.h"
#include "measure_swc_vme.h"
#include "measure_swc_J3_AEB.h"
#include "measure_swc_val_t1gc.h"
#include "measure_swc_tos.h"
#include "measure_swc_hmi.h"
#include "measure_swc_J3_TFL.h"
#include "measure_swc_J3_TFC.h"
#include "measure_swc_J3_FS.h"
#include "measure_swc_J3_IHBC.h"
#include "measure_swc_las.h"
#include "measure_swc_J3_RM.h"
#include "measure_swc_rlgs.h"
#include "j3_lane.proto"
#include "VMP.proto"
#include "HMI.proto"
#include "AEB.proto"
#include "j3_ihbc.proto"
#include "j3_fs.proto"
#include "LAS.proto"
#include "j3_tfl.proto"
#include "VMC.proto"
#include "j3_tfc.proto"
#include "TOS.proto"
#include "j3_rm.proto"
#include "ICAS.proto"
#include "VAL_T1GC.proto"
#include "RLGS.proto"
#include "VME.proto"
#include "j3_tsr.proto"
#include "j3_aeb.proto"
namespace {
[[gnu::unused]] static uint64_t GetTimeStamp() {
  auto time_now = std::chrono::system_clock::now();
  auto time_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
      time_now.time_since_epoch());
  return static_cast<uint64_t>(time_ms.count());
}
void Struct2Proto_J3_Cone_Road_Edge_BUS(const J3_Cone_Road_Edge_BUS& src, zpilot::j3_lane::proto::J3_Cone_Road_Edge_BUS* dst) {
  dst->set_coneroadedgeconfidence(src.ConeRoadEdgeConfidence);
  dst->set_coneroadedgemeasuringstatus(src.ConeRoadEdgeMeasuringStatus);
  dst->set_coneroadedgetypeclass(src.ConeRoadEdgeTypeClass);
  dst->set_coneroadedgequality(src.ConeRoadEdgeQuality);
  dst->set_coneroadedgeparsingconfidence(src.ConeRoadEdgeParsingConfidence);
  dst->set_coneroadedgetrackid(src.ConeRoadEdgeTrackID);
  dst->set_coneroadedgeviewrangestart(src.ConeRoadEdgeViewRangeStart);
  dst->set_coneroadedgeviewrangeend(src.ConeRoadEdgeViewRangeEnd);
  dst->set_coneroadedgemodelc0(src.ConeRoadEdgeModelC0);
  dst->set_coneroadedgemodelc1(src.ConeRoadEdgeModelC1);
  dst->set_coneroadedgemodelc2(src.ConeRoadEdgeModelC2);
  dst->set_coneroadedgemodelc3(src.ConeRoadEdgeModelC3);
  dst->set_coneroadedgetlc(src.ConeRoadEdgeTLC);
}

void Struct2Proto_J3_HPP_Line_BUS(const J3_HPP_Line_BUS& src, zpilot::j3_lane::proto::J3_HPP_Line_BUS* dst) {
  dst->set_hppline_confidence(src.HPPLine_Confidence);
  dst->set_hppline_first_valid(src.HPPLine_First_Valid);
  dst->set_hppline_second_valid(src.HPPLine_Second_Valid);
  dst->set_hppline_third_valid(src.HPPLine_Third_Valid);
  dst->set_hppline_measuringstatus(src.HPPLine_MeasuringStatus);
  dst->set_hppline_trackid(src.HPPLine_TrackID);
  dst->set_hppline_viewrange_end_first(src.HPPLine_ViewRange_End_First);
  dst->set_hppline_viewrange_end_second(src.HPPLine_ViewRange_End_Second);
  dst->set_hppline_viewrange_end_third(src.HPPLine_ViewRange_End_Third);
  dst->set_hpplinemodel_first_c0(src.HPPLineModel_First_C0);
  dst->set_hpplinemodel_first_c1(src.HPPLineModel_First_C1);
  dst->set_hpplinemodel_first_c2(src.HPPLineModel_First_C2);
  dst->set_hpplinemodel_first_c3(src.HPPLineModel_First_C3);
  dst->set_hppline_half_width(src.HPPLine_Half_Width);
  dst->set_hpplinemodel_second_c0(src.HPPLineModel_Second_C0);
  dst->set_hpplinemodel_second_c1(src.HPPLineModel_Second_C1);
  dst->set_hpplinemodel_second_c2(src.HPPLineModel_Second_C2);
  dst->set_hpplinemodel_second_c3(src.HPPLineModel_Second_C3);
  dst->set_hpplinemodel_third_c0(src.HPPLineModel_Third_C0);
  dst->set_hpplinemodel_third_c1(src.HPPLineModel_Third_C1);
  dst->set_hpplinemodel_third_c2(src.HPPLineModel_Third_C2);
  dst->set_hpplinemodel_third_c3(src.HPPLineModel_Third_C3);
}

void Struct2Proto_J3_LKA_Lane_BUS(const J3_LKA_Lane_BUS& src, zpilot::j3_lane::proto::J3_LKA_Lane_BUS* dst) {
  dst->set_laneconfidence(src.LaneConfidence);
  dst->set_lanemeasuringstatus(src.LaneMeasuringStatus);
  dst->set_lanetypeclass(src.LaneTypeClass);
  dst->set_lanemarkcolor(src.LaneMarkColor);
  dst->set_lanequality(src.LaneQuality);
  dst->set_lanecrossing(src.LaneCrossing);
  dst->set_obstacleflag(src.ObstacleFlag);
  dst->set_laneextranearpointtype(src.LaneExtraNearPointType);
  dst->set_laneextrafarpointtype(src.LaneExtraFarPointType);
  dst->set_laneparsingconfidence(src.LaneParsingConfidence);
  dst->set_stopline_relevancy(src.Stopline_Relevancy);
  dst->set_lanetrackid(src.LaneTrackID);
  dst->set_lanewidthmarking(src.LaneWidthMarking);
  dst->set_laneviewrangestart(src.LaneViewRangeStart);
  dst->set_laneviewrangeend(src.LaneViewRangeEnd);
  dst->set_lanemodelc0(src.LaneModelC0);
  dst->set_lanemodelc1(src.LaneModelC1);
  dst->set_lanemodelc2(src.LaneModelC2);
  dst->set_lanemodelc3(src.LaneModelC3);
  dst->set_lanetlc(src.LaneTLC);
  dst->set_laneextrafarpointposx(src.LaneExtraFarPointPosX);
  dst->set_laneextrafarpointposy(src.LaneExtraFarPointPosY);
  dst->set_laneextranearpointposx(src.LaneExtraNearPointPosX);
  dst->set_laneextranearpointposy(src.LaneExtraNearPointPosY);
}

void Struct2Proto_J3_Next_Lane_BUS(const J3_Next_Lane_BUS& src, zpilot::j3_lane::proto::J3_Next_Lane_BUS* dst) {
  dst->set_laneconfidence(src.LaneConfidence);
  dst->set_lanemeasuringstatus(src.LaneMeasuringStatus);
  dst->set_lanetypeclass(src.LaneTypeClass);
  dst->set_lanemarkcolor(src.LaneMarkColor);
  dst->set_lanequality(src.LaneQuality);
  dst->set_obstacleflag(src.ObstacleFlag);
  dst->set_laneextranearpointtype(src.LaneExtraNearPointType);
  dst->set_laneextrafarpointtype(src.LaneExtraFarPointType);
  dst->set_laneparsingconfidence(src.LaneParsingConfidence);
  dst->set_lanetrackid(src.LaneTrackID);
  dst->set_lanewidthmarking(src.LaneWidthMarking);
  dst->set_laneviewrangestart(src.LaneViewRangeStart);
  dst->set_laneviewrangeend(src.LaneViewRangeEnd);
  dst->set_lanemodelc0(src.LaneModelC0);
  dst->set_lanemodelc1(src.LaneModelC1);
  dst->set_lanemodelc2(src.LaneModelC2);
  dst->set_lanemodelc3(src.LaneModelC3);
  dst->set_laneextrafarpointposx(src.LaneExtraFarPointPosX);
  dst->set_laneextrafarpointposy(src.LaneExtraFarPointPosY);
  dst->set_laneextranearpointposx(src.LaneExtraNearPointPosX);
  dst->set_laneextranearpointposy(src.LaneExtraNearPointPosY);
}

void Struct2Proto_J3_Out_Lane_BUS(const J3_Out_Lane_BUS& src, zpilot::j3_lane::proto::J3_Out_Lane_BUS* dst) {
  dst->set_laneconfidence(src.LaneConfidence);
  dst->set_lanemeasuringstatus(src.LaneMeasuringStatus);
  dst->set_lanetypeclass(src.LaneTypeClass);
  dst->set_lanemarkcolor(src.LaneMarkColor);
  dst->set_lanequality(src.LaneQuality);
  dst->set_lanecrossing(src.LaneCrossing);
  dst->set_obstacleflag(src.ObstacleFlag);
  dst->set_laneextranearpointtype(src.LaneExtraNearPointType);
  dst->set_laneextrafarpointtype(src.LaneExtraFarPointType);
  dst->set_laneparsingconfidence(src.LaneParsingConfidence);
  dst->set_stopline_relevancy(src.Stopline_Relevancy);
  dst->set_lanetrackid(src.LaneTrackID);
  dst->set_lanewidthmarking(src.LaneWidthMarking);
  dst->set_laneviewrangestart(src.LaneViewRangeStart);
  dst->set_laneviewrangeend(src.LaneViewRangeEnd);
  dst->set_lanemodelc0(src.LaneModelC0);
  dst->set_lanemodelc1(src.LaneModelC1);
  dst->set_lanemodelc2(src.LaneModelC2);
  dst->set_lanemodelc3(src.LaneModelC3);
  dst->set_lanetlc(src.LaneTLC);
  dst->set_laneextrafarpointposx(src.LaneExtraFarPointPosX);
  dst->set_laneextrafarpointposy(src.LaneExtraFarPointPosY);
  dst->set_laneextranearpointposx(src.LaneExtraNearPointPosX);
  dst->set_laneextranearpointposy(src.LaneExtraNearPointPosY);
}

void Struct2Proto_J3_Road_Edge_BUS(const J3_Road_Edge_BUS& src, zpilot::j3_lane::proto::J3_Road_Edge_BUS* dst) {
  dst->set_laneconfidence(src.LaneConfidence);
  dst->set_lanemeasuringstatus(src.LaneMeasuringStatus);
  dst->set_lanetypeclass(src.LaneTypeClass);
  dst->set_lanemarkcolor(src.LaneMarkColor);
  dst->set_lanequality(src.LaneQuality);
  dst->set_obstacleflag(src.ObstacleFlag);
  dst->set_laneextranearpointtype(src.LaneExtraNearPointType);
  dst->set_laneextrafarpointtype(src.LaneExtraFarPointType);
  dst->set_laneparsingconfidence(src.LaneParsingConfidence);
  dst->set_stopline_relevancy(src.Stopline_Relevancy);
  dst->set_lanetrackid(src.LaneTrackID);
  dst->set_lanewidthmarking(src.LaneWidthMarking);
  dst->set_laneviewrangestart(src.LaneViewRangeStart);
  dst->set_laneviewrangeend(src.LaneViewRangeEnd);
  dst->set_lanemodelc0(src.LaneModelC0);
  dst->set_lanemodelc1(src.LaneModelC1);
  dst->set_lanemodelc2(src.LaneModelC2);
  dst->set_lanemodelc3(src.LaneModelC3);
  dst->set_lanetlc(src.LaneTLC);
  dst->set_laneextrafarpointposx(src.LaneExtraFarPointPosX);
  dst->set_laneextrafarpointposy(src.LaneExtraFarPointPosY);
  dst->set_laneextranearpointposx(src.LaneExtraNearPointPosX);
  dst->set_laneextranearpointposy(src.LaneExtraNearPointPosY);
}

void Struct2Proto_J3_Road_Information_BUS(const J3_Road_Information_BUS& src, zpilot::j3_lane::proto::J3_Road_Information_BUS* dst) {
  dst->set_roadtype(src.RoadType);
  dst->set_currentweather(src.CurrentWeather);
  dst->set_currenttime(src.CurrentTime);
  dst->set_lighttype(src.LightType);
  dst->set_disstoplinevalid(src.DisStoplineValid);
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_terraintype(src.TerrainType);
  dst->set_disstopline(src.DisStopline);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_lane::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_Lane_Extra_Type_BUS(const J3_Lane_Extra_Type_BUS& src, zpilot::j3_lane::proto::J3_Lane_Extra_Type_BUS* dst) {
  dst->set_change_point_valid(src.change_point_valid);
  dst->set_type_change_position(src.type_change_position);
  dst->set_second_line_type(src.second_line_type);
  dst->set_point_x(src.point_x);
  dst->set_point_y(src.point_y);
}

void Struct2Proto_J3_LANE_BUS(const J3_LANE_BUS& src, zpilot::j3_lane::proto::J3_LANE_BUS* dst) {
  dst->set_rollingcounter_lane(src.RollingCounter_Lane);
  Struct2Proto_J3_Cone_Road_Edge_BUS(src.Left_Cone_Road_Edge, dst->mutable_left_cone_road_edge());
  Struct2Proto_J3_Cone_Road_Edge_BUS(src.Right_Cone_Road_Edge, dst->mutable_right_cone_road_edge());
  Struct2Proto_J3_HPP_Line_BUS(src.HPP_Line, dst->mutable_hpp_line());
  Struct2Proto_J3_LKA_Lane_BUS(src.Left_LKA_Lane, dst->mutable_left_lka_lane());
  Struct2Proto_J3_LKA_Lane_BUS(src.Right_LKA_Lane, dst->mutable_right_lka_lane());
  Struct2Proto_J3_Next_Lane_BUS(src.Left_Next_Lane, dst->mutable_left_next_lane());
  Struct2Proto_J3_Next_Lane_BUS(src.Right_Next_Lane, dst->mutable_right_next_lane());
  Struct2Proto_J3_Out_Lane_BUS(src.Left_Out_Lane, dst->mutable_left_out_lane());
  Struct2Proto_J3_Out_Lane_BUS(src.Right_Out_Lane, dst->mutable_right_out_lane());
  Struct2Proto_J3_Road_Edge_BUS(src.Left_Road_Edge, dst->mutable_left_road_edge());
  Struct2Proto_J3_Road_Edge_BUS(src.Right_Road_Edge, dst->mutable_right_road_edge());
  Struct2Proto_J3_Road_Information_BUS(src.Road_Information, dst->mutable_road_information());
  Struct2Proto_J3_SYNC_BUS(src.J3_LANE_SYNC, dst->mutable_j3_lane_sync());
  for (const auto& struct_item : src.Lane_Extra_Type) {
      Struct2Proto_J3_Lane_Extra_Type_BUS(struct_item, dst->add_lane_extra_type());
   }
}

void Struct2Proto_LONP_ACCPLAN_BUS(const LONP_ACCPLAN_BUS& src, zpilot::VMP::proto::LONP_ACCPLAN_BUS* dst) {
  dst->set_acc_brakeprefer(src.ACC_BrakePrefer);
  dst->set_acc_axvcvaim(src.ACC_axvCvAim);
  dst->set_acc_axv_comfortbandlowervalue(src.ACC_axv_ComfortBandLowerValue);
  dst->set_acc_axv_comfortbanduppervalue(src.ACC_axv_ComfortBandUpperValue);
  dst->set_acc_deceleratejerk(src.ACC_DecelerateJerk);
  dst->set_acc_acceleratejerk(src.ACC_AccelerateJerk);
  dst->set_curvspdlim(src.CurvSpdLim);
}

void Struct2Proto_LONP_HMI_BUS(const LONP_HMI_BUS& src, zpilot::VMP::proto::LONP_HMI_BUS* dst) {
  dst->set_takeoverreq(src.TakeoverReq);
  dst->set_intelligentcurveactive(src.IntelligentCurveActive);
  dst->set_acc_tgtobjbardisp(src.ACC_TgtObjBarDisp);
  dst->set_acc_letgtobjbardisp(src.ACC_LeTgtObjBarDisp);
  dst->set_acc_ritgtobjbardisp(src.ACC_RiTgtObjBarDisp);
  dst->set_idp0(src.IDP0);
  dst->set_idp1(src.IDP1);
  dst->set_vehvelreqkap(src.VehVelReqKap);
  dst->set_followttc(src.FollowTTC);
  dst->set_follownummatrix(src.FollowNumMatrix);
  dst->set_followgappx(src.FollowGapPX);
  dst->set_followttcaccel(src.FollowTTCAccel);
  dst->set_targetidswitch(src.TargetIDSwitch);
  dst->set_insertspcenumletgo(src.InsertSpceNumLetgo);
  dst->set_insertspcenum(src.InsertSpceNum);
  dst->set_insertspcetend(src.InsertSpceTEnd);
  dst->set_insertspcesend(src.InsertSpceSEnd);
  dst->set_insertspcevend(src.InsertSpceVEnd);
}

void Struct2Proto_LONP_PSM_BUS(const LONP_PSM_BUS& src, zpilot::VMP::proto::LONP_PSM_BUS* dst) {
  dst->set_lonp_lcassesssts(src.LONP_LcAssessSts);
  dst->set_lonp_tstartdecel(src.LONP_tStartDecel);
  for (const auto& struct_item : src.LONP_AccelSubj) {
      dst->add_lonp_accelsubj(struct_item);
   }
}

void Struct2Proto_LONP_TrajPolyPara_BUS(const LONP_TrajPolyPara_BUS& src, zpilot::VMP::proto::LONP_TrajPolyPara_BUS* dst) {
  dst->set_vaild(src.Vaild);
  dst->set_p0(src.P0);
  dst->set_p1(src.P1);
  dst->set_p2(src.P2);
  dst->set_p3(src.P3);
  dst->set_p4(src.P4);
  dst->set_p5(src.P5);
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::VMP::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_Poly_BUS(const Poly_BUS& src, zpilot::VMP::proto::Poly_BUS* dst) {
  dst->set_start(src.start);
  dst->set_end(src.end);
  for (const auto& struct_item : src.poly_vec) {
      dst->add_poly_vec(struct_item);
   }
}

void Struct2Proto_VMP_TRAJ_BUS(const VMP_TRAJ_BUS& src, zpilot::VMP::proto::VMP_TRAJ_BUS* dst) {
  dst->set_st_poly_valid(src.st_poly_valid);
  dst->set_xy_poly_valid(src.xy_poly_valid);
  dst->set_updatecnt(src.updateCnt);
  dst->set_ref_lane_id(src.ref_lane_id);
  Struct2Proto_Poly_BUS(src.st_poly, dst->mutable_st_poly());
  Struct2Proto_Poly_BUS(src.xy_poly, dst->mutable_xy_poly());
}

void Struct2Proto_VMP_STS_BUS(const VMP_STS_BUS& src, zpilot::VMP::proto::VMP_STS_BUS* dst) {
  dst->set_pln_run_sts(src.pln_run_sts);
  dst->set_lgt_pln_sts(src.lgt_pln_sts);
  dst->set_lat_pln_sts(src.lat_pln_sts);
  dst->set_lgt_drive_sts(src.lgt_drive_sts);
  dst->set_lc_exec_sts(src.lc_exec_sts);
  dst->set_nudge_exec_sts(src.nudge_exec_sts);
  dst->set_lc_req_sync_id(src.lc_req_sync_id);
  dst->set_lc_failed_reason(src.lc_failed_reason);
  dst->set_lc_feasibility_conds(src.lc_feasibility_conds);
  dst->set_pln_inhibited_reason(src.pln_inhibited_reason);
  dst->set_pln_failed_reason(src.pln_failed_reason);
}

void Struct2Proto_LATP_HMI_BUS(const LATP_HMI_BUS& src, zpilot::VMP::proto::LATP_HMI_BUS* dst) {
  dst->set_infodisphmi(src.InfoDispHMI);
  dst->set_lctarlocationdx(src.LcTarLocationDx);
  dst->set_lctarlocationdy(src.LcTarLocationDy);
  dst->set_lctarlocationhead(src.LcTarLocationHead);
  for (const auto& struct_item : src.LcTarPathPointX) {
      dst->add_lctarpathpointx(struct_item);
   }
  for (const auto& struct_item : src.LcTarPathPointY) {
      dst->add_lctarpathpointy(struct_item);
   }
}

void Struct2Proto_VMP_Measurement(const VMP_Measurement& src, zpilot::VMP::proto::VMP_Measurement* dst) {
  dst->set_vmp_version(src.VMP_Version);
  dst->set_vmp_updatecnt(src.VMP_UpdateCnt);
  dst->set_lonp_followupdate(src.LONP_FollowUpdate);
  dst->set_lonp_follow_counter(src.LONP_Follow_Counter);
  dst->set_lonp_acctgtobjvy(src.LONP_ACCTgtObjVy);
  dst->set_lonp_vlcinternalacck20(src.LONP_VlcInternalAccK20);
  dst->set_lonp_accelal(src.LONP_accelAL);
  dst->set_lonp_accelarb(src.LONP_accelArb);
  dst->set_vmp_obj_front_risk_id(src.VMP_obj_front_risk_id);
  dst->set_vmp_obj_back_risk_id(src.VMP_obj_back_risk_id);
  dst->set_vmp_veh_lc_pos(src.VMP_veh_lc_pos);
  dst->set_vmp_veh_in_force_cancel_lane(src.VMP_veh_in_force_cancel_lane);
  dst->set_vmp_obj_select_front_min_dx(src.VMP_obj_select_front_Min_Dx);
  dst->set_vmp_obj_select_front_min_ttc(src.VMP_obj_select_front_Min_TTC);
  dst->set_vmp_obj_select_back_max_dx(src.VMP_obj_select_back_Max_Dx);
  dst->set_vmp_obj_select_back_min_ttc(src.VMP_obj_select_back_Min_TTC);
  dst->set_vmp_tarpathresk_f(src.VMP_TarPathResk_F);
  dst->set_vmp_tarpathresk_r(src.VMP_TarPathResk_R);
  dst->set_vmp_forcecancelpathindex(src.VMP_forceCancelPathIndex);
  dst->set_vmp_lc_lane_chk_loose_pass(src.VMP_lc_lane_chk_loose_pass);
  dst->set_vmp_lc_lane_chk_lm_pass(src.VMP_lc_lane_chk_lm_pass);
  dst->set_vmp_lane_force_cancel_pass(src.VMP_lane_force_cancel_pass);
  dst->set_vmp_lc_lane_cancel_pass(src.VMP_lc_lane_cancel_pass);
  dst->set_vmp_lc_lane_chk_lm_reason(src.VMP_lc_lane_chk_lm_reason);
  dst->set_vmp_lc_lane_chk_loose_reason(src.VMP_lc_lane_chk_loose_reason);
  dst->set_vmp_lane_force_cancel_reason(src.VMP_lane_force_cancel_reason);
  dst->set_vmp_lc_lane_cancel_reason(src.VMP_lc_lane_cancel_reason);
  dst->set_vmp_nudge_dis(src.VMP_Nudge_Dis);
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_VMP_Herbeat_Info, dst->mutable_swcout_vmp_herbeat_info());
  Struct2Proto_VMP_TRAJ_BUS(src.SwcOut_VMP_TRAJ, dst->mutable_swcout_vmp_traj());
  Struct2Proto_VMP_STS_BUS(src.SwcOut_VMP_STS, dst->mutable_swcout_vmp_sts());
  Struct2Proto_LATP_HMI_BUS(src.SwcOut_LATP_HMI, dst->mutable_swcout_latp_hmi());
  Struct2Proto_LONP_ACCPLAN_BUS(src.SwcOut_LONP_ACCPLAN, dst->mutable_swcout_lonp_accplan());
  Struct2Proto_LONP_HMI_BUS(src.SwcOut_LONP_HMI, dst->mutable_swcout_lonp_hmi());
  for (const auto& struct_item : src.VMP_reserve) {
      dst->add_vmp_reserve(struct_item);
   }
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::HMI::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_HMI_GENERAL_INFO_BUS(const HMI_GENERAL_INFO_BUS& src, zpilot::HMI::proto::HMI_GENERAL_INFO_BUS* dst) {
  dst->set_acc_status(src.ACC_Status);
  dst->set_fcw_status(src.FCW_Status);
  dst->set_aeb_status(src.AEB_Status);
  dst->set_ldw_status(src.LDW_Status);
  dst->set_ldp_status(src.LDP_Status);
  dst->set_elk_status(src.ELK_Status);
  dst->set_ica_status(src.ICA_Status);
  dst->set_dai_status(src.DAI_Status);
  dst->set_ie_status(src.IE_Status);
  dst->set_ihbc_status(src.IHBC_Status);
  dst->set_tsr_status(src.TSR_Status);
  dst->set_sla_status(src.SLA_Status);
  dst->set_isl_status(src.ISL_Status);
  dst->set_tli_status(src.TLI_Status);
  dst->set_alc_status(src.ALC_Status);
  dst->set_pilot_status(src.Pilot_Status);
  dst->set_acc_spdset(src.ACC_SpdSet);
  dst->set_acc_timegapset(src.ACC_TimeGapSet);
  dst->set_slaspdlim(src.SLASpdLim);
  dst->set_slaspdlimwarn(src.SLASpdLimWarn);
  dst->set_tsrsgngiway(src.TSRSgnGiWay);
  dst->set_tsrsgnforb(src.TSRSgnForb);
  dst->set_tsrsgnlongstaydisp(src.TSRSgnLongStayDisp);
  dst->set_lssintervention(src.LSSIntervention);
  dst->set_acc_text_info(src.ACC_Text_Info);
  dst->set_tja_text_info(src.TJA_Text_Info);
  dst->set_alc_text_info(src.ALC_Text_Info);
  dst->set_noa_text_info(src.NOA_Text_Info);
  dst->set_aeb_text_info(src.AEB_Text_Info);
  dst->set_adc_text_info(src.ADC_Text_Info);
  dst->set_adc_text_warn(src.ADC_Text_Warn);
  dst->set_adc_voice_info(src.ADC_Voice_Info);
  dst->set_adc_warnform(src.ADC_WarnForm);
  dst->set_tli_info(src.TLI_Info);
  dst->set_lanechange_display(src.LaneChange_Display);
  dst->set_lanechange_dxend(src.LaneChange_dxEnd);
  dst->set_lanechange_dyend(src.LaneChange_dyEnd);
}

void Struct2Proto_HMI_LANE_BUS(const HMI_LANE_BUS& src, zpilot::HMI::proto::HMI_LANE_BUS* dst) {
  dst->set_line01_type(src.Line01_Type);
  dst->set_line02_type(src.Line02_Type);
  dst->set_line03_type(src.Line03_Type);
  dst->set_line04_type(src.Line04_Type);
  dst->set_roadedge01_type(src.RoadEdge01_Type);
  dst->set_roadedge02_type(src.RoadEdge02_Type);
  dst->set_line01_color(src.Line01_Color);
  dst->set_line02_color(src.Line02_Color);
  dst->set_line03_color(src.Line03_Color);
  dst->set_line04_color(src.Line04_Color);
  dst->set_roadedge01_color(src.RoadEdge01_Color);
  dst->set_roadedge02_color(src.RoadEdge02_Color);
  dst->set_line01_dxstart(src.Line01_dxStart);
  dst->set_line01_dxend(src.Line01_dxEnd);
  dst->set_line01_c0(src.Line01_C0);
  dst->set_line01_c1(src.Line01_C1);
  dst->set_line01_c2(src.Line01_C2);
  dst->set_line01_c3(src.Line01_C3);
  dst->set_line02_dxstart(src.Line02_dxStart);
  dst->set_line02_dxend(src.Line02_dxEnd);
  dst->set_line02_c0(src.Line02_C0);
  dst->set_line02_c1(src.Line02_C1);
  dst->set_line02_c2(src.Line02_C2);
  dst->set_line02_c3(src.Line02_C3);
  dst->set_line03_dxstart(src.Line03_dxStart);
  dst->set_line03_dxend(src.Line03_dxEnd);
  dst->set_line03_c0(src.Line03_C0);
  dst->set_line03_c1(src.Line03_C1);
  dst->set_line03_c2(src.Line03_C2);
  dst->set_line03_c3(src.Line03_C3);
  dst->set_line04_dxstart(src.Line04_dxStart);
  dst->set_line04_dxend(src.Line04_dxEnd);
  dst->set_line04_c0(src.Line04_C0);
  dst->set_line04_c1(src.Line04_C1);
  dst->set_line04_c2(src.Line04_C2);
  dst->set_line04_c3(src.Line04_C3);
  dst->set_roadedge01_dxstart(src.RoadEdge01_dxStart);
  dst->set_roadedge01_dxend(src.RoadEdge01_dxEnd);
  dst->set_roadedge01_c0(src.RoadEdge01_C0);
  dst->set_roadedge01_c1(src.RoadEdge01_C1);
  dst->set_roadedge01_c2(src.RoadEdge01_C2);
  dst->set_roadedge01_c3(src.RoadEdge01_C3);
  dst->set_roadedge02_dxstart(src.RoadEdge02_dxStart);
  dst->set_roadedge02_dxend(src.RoadEdge02_dxEnd);
  dst->set_roadedge02_c0(src.RoadEdge02_C0);
  dst->set_roadedge02_c1(src.RoadEdge02_C1);
  dst->set_roadedge02_c2(src.RoadEdge02_C2);
  dst->set_roadedge02_c3(src.RoadEdge02_C3);
  dst->set_line01_markingwidth(src.Line01_MarkingWidth);
  dst->set_line01_confidence(src.Line01_Confidence);
  dst->set_line02_markingwidth(src.Line02_MarkingWidth);
  dst->set_line02_confidence(src.Line02_Confidence);
  dst->set_line03_markingwidth(src.Line03_MarkingWidth);
  dst->set_line03_confidence(src.Line03_Confidence);
  dst->set_line04_markingwidth(src.Line04_MarkingWidth);
  dst->set_line04_confidence(src.Line04_Confidence);
  dst->set_roadedge01_markingwidth(src.RoadEdge01_MarkingWidth);
  dst->set_roadedge01_confidence(src.RoadEdge01_Confidence);
  dst->set_roadedge02_markingwidth(src.RoadEdge02_MarkingWidth);
  dst->set_roadedge02_confidence(src.RoadEdge02_Confidence);
}

void Struct2Proto_HMI_OBJECT_BUS(const HMI_OBJECT_BUS& src, zpilot::HMI::proto::HMI_OBJECT_BUS* dst) {
  dst->set_tgt_type_01(src.Tgt_Type_01);
  dst->set_tgt_color_01(src.Tgt_Color_01);
  dst->set_tgt_detn_01(src.Tgt_Detn_01);
  dst->set_tgt_type_02(src.Tgt_Type_02);
  dst->set_tgt_color_02(src.Tgt_Color_02);
  dst->set_tgt_detn_02(src.Tgt_Detn_02);
  dst->set_tgt_type_03(src.Tgt_Type_03);
  dst->set_tgt_color_03(src.Tgt_Color_03);
  dst->set_tgt_detn_03(src.Tgt_Detn_03);
  dst->set_tgt_type_04(src.Tgt_Type_04);
  dst->set_tgt_color_04(src.Tgt_Color_04);
  dst->set_tgt_detn_04(src.Tgt_Detn_04);
  dst->set_tgt_type_05(src.Tgt_Type_05);
  dst->set_tgt_color_05(src.Tgt_Color_05);
  dst->set_tgt_detn_05(src.Tgt_Detn_05);
  dst->set_tgt_type_06(src.Tgt_Type_06);
  dst->set_tgt_color_06(src.Tgt_Color_06);
  dst->set_tgt_detn_06(src.Tgt_Detn_06);
  dst->set_tgt_type_07(src.Tgt_Type_07);
  dst->set_tgt_color_07(src.Tgt_Color_07);
  dst->set_tgt_detn_07(src.Tgt_Detn_07);
  dst->set_tgt_type_08(src.Tgt_Type_08);
  dst->set_tgt_color_08(src.Tgt_Color_08);
  dst->set_tgt_detn_08(src.Tgt_Detn_08);
  dst->set_tgt_iscipv_01(src.Tgt_IsCIPV_01);
  dst->set_tgt_iscipv_02(src.Tgt_IsCIPV_02);
  dst->set_tgt_iscipv_03(src.Tgt_IsCIPV_03);
  dst->set_tgt_iscipv_04(src.Tgt_IsCIPV_04);
  dst->set_tgt_iscipv_05(src.Tgt_IsCIPV_05);
  dst->set_tgt_iscipv_06(src.Tgt_IsCIPV_06);
  dst->set_tgt_iscipv_07(src.Tgt_IsCIPV_07);
  dst->set_tgt_iscipv_08(src.Tgt_IsCIPV_08);
  dst->set_tgt_movingstatus_01(src.Tgt_movingStatus_01);
  dst->set_tgt_movingstatus_02(src.Tgt_movingStatus_02);
  dst->set_tgt_movingstatus_03(src.Tgt_movingStatus_03);
  dst->set_tgt_movingstatus_04(src.Tgt_movingStatus_04);
  dst->set_tgt_movingstatus_05(src.Tgt_movingStatus_05);
  dst->set_tgt_movingstatus_06(src.Tgt_movingStatus_06);
  dst->set_tgt_movingstatus_07(src.Tgt_movingStatus_07);
  dst->set_tgt_movingstatus_08(src.Tgt_movingStatus_08);
  dst->set_tgt_heading_01(src.Tgt_Heading_01);
  dst->set_tgt_heading_02(src.Tgt_Heading_02);
  dst->set_tgt_heading_03(src.Tgt_Heading_03);
  dst->set_tgt_heading_04(src.Tgt_Heading_04);
  dst->set_tgt_heading_05(src.Tgt_Heading_05);
  dst->set_tgt_heading_06(src.Tgt_Heading_06);
  dst->set_tgt_heading_07(src.Tgt_Heading_07);
  dst->set_tgt_heading_08(src.Tgt_Heading_08);
  dst->set_tgt_dx_01(src.Tgt_Dx_01);
  dst->set_tgt_dy_01(src.Tgt_Dy_01);
  dst->set_tgt_dx_02(src.Tgt_Dx_02);
  dst->set_tgt_dy_02(src.Tgt_Dy_02);
  dst->set_tgt_dx_03(src.Tgt_Dx_03);
  dst->set_tgt_dy_03(src.Tgt_Dy_03);
  dst->set_tgt_dx_04(src.Tgt_Dx_04);
  dst->set_tgt_dy_04(src.Tgt_Dy_04);
  dst->set_tgt_dx_05(src.Tgt_Dx_05);
  dst->set_tgt_dy_05(src.Tgt_Dy_05);
  dst->set_tgt_dx_06(src.Tgt_Dx_06);
  dst->set_tgt_dy_06(src.Tgt_Dy_06);
  dst->set_tgt_dx_07(src.Tgt_Dx_07);
  dst->set_tgt_dy_07(src.Tgt_Dy_07);
  dst->set_tgt_dx_08(src.Tgt_Dx_08);
  dst->set_tgt_dy_08(src.Tgt_Dy_08);
  dst->set_tgt_vx_01(src.Tgt_Vx_01);
  dst->set_tgt_vy_01(src.Tgt_Vy_01);
  dst->set_tgt_width_01(src.Tgt_Width_01);
  dst->set_tgt_height_01(src.Tgt_Height_01);
  dst->set_tgt_length_01(src.Tgt_length_01);
  dst->set_tgt_vx_02(src.Tgt_Vx_02);
  dst->set_tgt_vy_02(src.Tgt_Vy_02);
  dst->set_tgt_width_02(src.Tgt_Width_02);
  dst->set_tgt_height_02(src.Tgt_Height_02);
  dst->set_tgt_length_02(src.Tgt_length_02);
  dst->set_tgt_vx_03(src.Tgt_Vx_03);
  dst->set_tgt_vy_03(src.Tgt_Vy_03);
  dst->set_tgt_width_03(src.Tgt_Width_03);
  dst->set_tgt_height_03(src.Tgt_Height_03);
  dst->set_tgt_length_03(src.Tgt_length_03);
  dst->set_tgt_vx_04(src.Tgt_Vx_04);
  dst->set_tgt_vy_04(src.Tgt_Vy_04);
  dst->set_tgt_width_04(src.Tgt_Width_04);
  dst->set_tgt_height_04(src.Tgt_Height_04);
  dst->set_tgt_length_04(src.Tgt_length_04);
  dst->set_tgt_vx_05(src.Tgt_Vx_05);
  dst->set_tgt_vy_05(src.Tgt_Vy_05);
  dst->set_tgt_width_05(src.Tgt_Width_05);
  dst->set_tgt_height_05(src.Tgt_Height_05);
  dst->set_tgt_length_05(src.Tgt_length_05);
  dst->set_tgt_vx_06(src.Tgt_Vx_06);
  dst->set_tgt_vy_06(src.Tgt_Vy_06);
  dst->set_tgt_width_06(src.Tgt_Width_06);
  dst->set_tgt_height_06(src.Tgt_Height_06);
  dst->set_tgt_length_06(src.Tgt_length_06);
  dst->set_tgt_vx_07(src.Tgt_Vx_07);
  dst->set_tgt_vy_07(src.Tgt_Vy_07);
  dst->set_tgt_width_07(src.Tgt_Width_07);
  dst->set_tgt_height_07(src.Tgt_Height_07);
  dst->set_tgt_length_07(src.Tgt_length_07);
  dst->set_tgt_vx_08(src.Tgt_Vx_08);
  dst->set_tgt_vy_08(src.Tgt_Vy_08);
  dst->set_tgt_width_08(src.Tgt_Width_08);
  dst->set_tgt_height_08(src.Tgt_Height_08);
  dst->set_tgt_length_08(src.Tgt_length_08);
}

void Struct2Proto_HMI_Light_Req_MSG_BUS(const HMI_Light_Req_MSG_BUS& src, zpilot::HMI::proto::HMI_Light_Req_MSG_BUS* dst) {
  dst->set_brklireq(src.BrkLiReq);
  dst->set_frntwiprsts(src.Frntwiprsts);
  dst->set_turnlightind(src.Turnlightind);
  dst->set_beamactivests(src.BeamactiveSts);
  dst->set_beamlightreq(src.Beamlightreq);
  dst->set_emeglampreq(src.EmeglampReq);
  dst->set_ihbc_status(src.IHBC_Status);
  dst->set_ihbc_highbeamreq(src.IHBC_HighBeamReq);
}

void Struct2Proto_HMI_Measurement(const HMI_Measurement& src, zpilot::HMI::proto::HMI_Measurement* dst) {
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_HMI_Herbeat_Info, dst->mutable_swcout_hmi_herbeat_info());
  Struct2Proto_HMI_OBJECT_BUS(src.SwcOut_HMI_OBJECT, dst->mutable_swcout_hmi_object());
  Struct2Proto_HMI_LANE_BUS(src.SwcOut_HMI_LANE, dst->mutable_swcout_hmi_lane());
  Struct2Proto_HMI_GENERAL_INFO_BUS(src.SwcOut_HMI_GENERAL_INFO, dst->mutable_swcout_hmi_general_info());
  Struct2Proto_HMI_Light_Req_MSG_BUS(src.SwcOut_HMI_Light_Req, dst->mutable_swcout_hmi_light_req());
  for (const auto& struct_item : src.HMI_reserve) {
      dst->add_hmi_reserve(struct_item);
   }
  dst->set_hmi_update(src.HMI_Update);
  dst->set_hmi_version(src.HMI_Version);
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_AEB_BRKINFO_BUS(const AEB_BRKINFO_BUS& src, zpilot::AEB::proto::AEB_BRKINFO_BUS* dst) {
  dst->set_aebdecctrlreqest(src.AEBDecCtrlReqest);
  dst->set_aebreq(src.AEBReq);
  dst->set_awbrequest(src.AWBRequest);
  dst->set_awblevel(src.AWBLevel);
  dst->set_prefillrequest(src.PrefillRequest);
  dst->set_hbalevel(src.HBAlevel);
  dst->set_hbarequest(src.HBArequest);
  dst->set_fcwmode(src.FCWMode);
  dst->set_aebmode(src.AEBMode);
  dst->set_fctbmode(src.FCTBMode);
  dst->set_hazdlmpreq(src.HazdLmpReq);
  dst->set_textinfo(src.TextInfo);
  dst->set_textinfowarn(src.TextinfoWarn);
  dst->set_aebtardec(src.AEBTarDec);
}

void Struct2Proto_Property(const Property& src, zpilot::AEB::proto::Property* dst) {
  dst->set_p_lgt(src.p_lgt);
  dst->set_p_lat(src.p_lat);
  dst->set_spd(src.spd);
  dst->set_v_lgt(src.v_lgt);
  dst->set_v_lat(src.v_lat);
  dst->set_a_lgt(src.a_lgt);
  dst->set_a_lat(src.a_lat);
  dst->set_a(src.a);
  dst->set_curvature(src.curvature);
}

void Struct2Proto_MotionType(const MotionType& src, zpilot::AEB::proto::MotionType* dst) {
  dst->set_stationary(src.stationary);
  dst->set_moving_oncoming(src.moving_oncoming);
  dst->set_parallell_vehicle_long_predict(src.parallell_vehicle_long_predict);
  dst->set_parallell_vehicle_short_predict(src.parallell_vehicle_short_predict);
  dst->set_object_is_vehicle(src.object_is_vehicle);
  dst->set_object_is_motor_vehicle(src.object_is_motor_vehicle);
  dst->set_curved_motion(src.curved_motion);
  dst->set_side_is_closest(src.side_is_closest);
  dst->set_abs_heading(src.abs_heading);
}

void Struct2Proto_BoundingBoxInfo(const BoundingBoxInfo& src, zpilot::AEB::proto::BoundingBoxInfo* dst) {
  dst->set_length_side_lat(src.length_side_lat);
  dst->set_length_side_lgt(src.length_side_lgt);
  dst->set_sin_rotation(src.sin_rotation);
  dst->set_cos_rotation(src.cos_rotation);
}

void Struct2Proto_ShortPredTime(const ShortPredTime& src, zpilot::AEB::proto::ShortPredTime* dst) {
  dst->set_ttr(src.ttr);
  dst->set_ttm(src.ttm);
  dst->set_ttm_selected(src.ttm_selected);
  dst->set_inpath(src.inpath);
  dst->set_inpath_predict_position(src.inpath_predict_position);
  dst->set_inpath_current_position(src.inpath_current_position);
  dst->set_use_inpath_calculation(src.use_inpath_calculation);
  dst->set_use_out_offpath_calculation(src.use_out_offpath_calculation);
  dst->set_prediction_valid(src.prediction_valid);
}

void Struct2Proto_LongPredTime(const LongPredTime& src, zpilot::AEB::proto::LongPredTime* dst) {
  dst->set_ttr(src.ttr);
  dst->set_inpath(src.inpath);
  dst->set_inpath_predict_position(src.inpath_predict_position);
  dst->set_inpath_current_position(src.inpath_current_position);
  dst->set_use_inpath_calculation(src.use_inpath_calculation);
  dst->set_use_out_offpath_calculation(src.use_out_offpath_calculation);
  dst->set_prediction_valid(src.prediction_valid);
}

void Struct2Proto_Offsets(const Offsets& src, zpilot::AEB::proto::Offsets* dst) {
  dst->set_offs_lgt_long_predict(src.offs_lgt_long_predict);
  dst->set_offs_lat_long_predict(src.offs_lat_long_predict);
  dst->set_offs_lgt_short_predict(src.offs_lgt_short_predict);
  dst->set_offs_lat_short_predict(src.offs_lat_short_predict);
  dst->set_offs_lat_manoeuvre(src.offs_lat_manoeuvre);
  dst->set_offs_lat_inpath_primary_target(src.offs_lat_inpath_primary_target);
  dst->set_offs_lat_inpath_close_edge(src.offs_lat_inpath_close_edge);
  dst->set_offs_lat_inpath_far_edge(src.offs_lat_inpath_far_edge);
  dst->set_offs_lat_intersection(src.offs_lat_intersection);
  dst->set_offs_lat_multiple_target(src.offs_lat_multiple_target);
}

void Struct2Proto_ObjDataInfo(const ObjDataInfo& src, zpilot::AEB::proto::ObjDataInfo* dst) {
  Struct2Proto_Property(src.porperty, dst->mutable_porperty());
  Struct2Proto_MotionType(src.motion_type, dst->mutable_motion_type());
  Struct2Proto_BoundingBoxInfo(src.bounding_box, dst->mutable_bounding_box());
  Struct2Proto_ShortPredTime(src.short_pred_time, dst->mutable_short_pred_time());
  Struct2Proto_LongPredTime(src.long_pred_time, dst->mutable_long_pred_time());
  Struct2Proto_Offsets(src.offsets, dst->mutable_offsets());
}

void Struct2Proto_EgoInfo(const EgoInfo& src, zpilot::AEB::proto::EgoInfo* dst) {
  dst->set_v_lgt(src.v_lgt);
  dst->set_v_lat(src.v_lat);
  dst->set_a_lgt(src.a_lgt);
  dst->set_a_lat(src.a_lat);
  dst->set_yaw_rate(src.yaw_rate);
  dst->set_curvature(src.curvature);
  dst->set_curve_radius(src.curve_radius);
  dst->set_steer_angle(src.steer_angle);
  dst->set_steer_angle_spd(src.steer_angle_spd);
  dst->set_acceleration_pedal_position(src.acceleration_pedal_position);
  dst->set_master_cylinder_pressure(src.master_cylinder_pressure);
  dst->set_gear(src.gear);
  dst->set_vehicle_standstill_status(src.vehicle_standstill_status);
  dst->set_brake_pedal_applied(src.brake_pedal_applied);
  dst->set_acc_request_acceleration(src.acc_request_acceleration);
}

void Struct2Proto_MotionRequestIntv(const MotionRequestIntv& src, zpilot::AEB::proto::MotionRequestIntv* dst) {
  dst->set_a_lat_request(src.a_lat_request);
  dst->set_a_lat_quality(src.a_lat_quality);
  dst->set_a_neg_lgt_request(src.a_neg_lgt_request);
  dst->set_jerk_neg_lgt_request(src.jerk_neg_lgt_request);
  dst->set_crvt_request_left(src.crvt_request_left);
  dst->set_crvt_rate_request_left(src.crvt_rate_request_left);
  dst->set_crvt_request_right(src.crvt_request_right);
  dst->set_crvt_rate_request_right(src.crvt_rate_request_right);
}

void Struct2Proto_PrimaryTargetIntv(const PrimaryTargetIntv& src, zpilot::AEB::proto::PrimaryTargetIntv* dst) {
  dst->set_obj_id(src.obj_id);
  dst->set_obj_type(src.obj_type);
  dst->set_new_ta_found(src.new_ta_found);
  dst->set_posn_lgt(src.posn_lgt);
  dst->set_posn_lat(src.posn_lat);
  dst->set_v_lgt(src.v_lgt);
  dst->set_v_lat(src.v_lat);
  dst->set_a_lgt(src.a_lgt);
  dst->set_a_lat(src.a_lat);
  dst->set_ttc_val(src.ttc_val);
  dst->set_trigger_flag(src.trigger_flag);
  dst->set_obs_conf(src.obs_conf);
  dst->set_ang_dir(src.ang_dir);
}

void Struct2Proto_PrimaryTargetIntvInfo(const PrimaryTargetIntvInfo& src, zpilot::AEB::proto::PrimaryTargetIntvInfo* dst) {
  Struct2Proto_MotionRequestIntv(src.motion_request_intv, dst->mutable_motion_request_intv());
  Struct2Proto_PrimaryTargetIntv(src.primary_target_intv, dst->mutable_primary_target_intv());
}

void Struct2Proto_MotionRequestWarn(const MotionRequestWarn& src, zpilot::AEB::proto::MotionRequestWarn* dst) {
  dst->set_a_lat_request(src.a_lat_request);
  dst->set_a_neg_lgt_request_forwarn(src.a_neg_lgt_request_forwarn);
}

void Struct2Proto_PrimaryTargetWarn(const PrimaryTargetWarn& src, zpilot::AEB::proto::PrimaryTargetWarn* dst) {
  dst->set_obj_id(src.obj_id);
  dst->set_obj_type(src.obj_type);
  dst->set_new_ta_found(src.new_ta_found);
  dst->set_posn_lgt(src.posn_lgt);
  dst->set_posn_lat(src.posn_lat);
  dst->set_v_lgt(src.v_lgt);
  dst->set_v_lat(src.v_lat);
  dst->set_a_lgt(src.a_lgt);
  dst->set_a_lat(src.a_lat);
  dst->set_ttc_val(src.ttc_val);
  dst->set_trigger_flag(src.trigger_flag);
  dst->set_obs_conf(src.obs_conf);
  dst->set_ang_dir(src.ang_dir);
}

void Struct2Proto_PrimaryTargetWarnInfo(const PrimaryTargetWarnInfo& src, zpilot::AEB::proto::PrimaryTargetWarnInfo* dst) {
  Struct2Proto_MotionRequestWarn(src.motion_request_warn, dst->mutable_motion_request_warn());
  Struct2Proto_PrimaryTargetWarn(src.primary_target_warn, dst->mutable_primary_target_warn());
}

void Struct2Proto_Fullbrake(const Fullbrake& src, zpilot::AEB::proto::Fullbrake* dst) {
  dst->set_curvature_absolute_maximum(src.curvature_absolute_maximum);
  dst->set_curvature_rateabsolute_maximum(src.curvature_rateabsolute_maximum);
  dst->set_a_lat_threthold(src.a_lat_threthold);
  dst->set_a_neg_lgt_threthold(src.a_neg_lgt_threthold);
  dst->set_jerk_longitudinal_negative_minimum(src.jerk_longitudinal_negative_minimum);
  dst->set_steering_threat(src.steering_threat);
  dst->set_braking_threat(src.braking_threat);
  dst->set_a_lgt_threat(src.a_lgt_threat);
  dst->set_a_lat_quality(src.a_lat_quality);
  dst->set_fullbrake_counter(src.fullbrake_counter);
  dst->set_fullbrake_confirm(src.fullbrake_confirm);
  dst->set_intv_obj_counter(src.intv_obj_counter);
  dst->set_intv_obj_confirm(src.intv_obj_confirm);
}

void Struct2Proto_Prebrake(const Prebrake& src, zpilot::AEB::proto::Prebrake* dst) {
  dst->set_curvature_absolute_comfort(src.curvature_absolute_comfort);
  dst->set_curvature_rate_absolute_comfort(src.curvature_rate_absolute_comfort);
  dst->set_a_lat_threthold(src.a_lat_threthold);
  dst->set_a_neg_lgt_threthold(src.a_neg_lgt_threthold);
  dst->set_steering_threat(src.steering_threat);
  dst->set_braking_threat(src.braking_threat);
  dst->set_a_lgt_threat(src.a_lgt_threat);
  dst->set_a_lat_quality(src.a_lat_quality);
  dst->set_prebrake_counter(src.prebrake_counter);
  dst->set_prebrake_confirm(src.prebrake_confirm);
  dst->set_intv_obj_counter(src.intv_obj_counter);
  dst->set_intv_obj_confirm(src.intv_obj_confirm);
}

void Struct2Proto_Prewarn(const Prewarn& src, zpilot::AEB::proto::Prewarn* dst) {
  dst->set_brake_num(src.brake_num);
  dst->set_obj_valid(src.obj_valid);
  dst->set_steer_valid(src.steer_valid);
  dst->set_fcw_counter(src.fcw_counter);
  dst->set_fcw_confirm(src.fcw_confirm);
  dst->set_fcw_obj_counter(src.fcw_obj_counter);
  dst->set_fcw_obj_confirm(src.fcw_obj_confirm);
}

void Struct2Proto_RiskConditionInfo(const RiskConditionInfo& src, zpilot::AEB::proto::RiskConditionInfo* dst) {
  Struct2Proto_Fullbrake(src.fullbrake, dst->mutable_fullbrake());
  Struct2Proto_Prebrake(src.prebrake, dst->mutable_prebrake());
  Struct2Proto_Prewarn(src.prewarn, dst->mutable_prewarn());
  dst->set_confidence_info_flag(src.confidence_info_flag);
  dst->set_sceniaro_flag(src.Sceniaro_Flag);
  dst->set_sceniaro_check_result(src.Sceniaro_Check_Result);
  dst->set_sceniaro_host_state(src.Sceniaro_Host_State);
}

void Struct2Proto_InhibitInfo(const InhibitInfo& src, zpilot::AEB::proto::InhibitInfo* dst) {
  dst->set_confidence_info_flag(src.confidence_info_flag);
  dst->set_aeb_inhibit_flag_1(src.aeb_inhibit_flag_1);
  dst->set_aeb_inhibit_flag_2(src.aeb_inhibit_flag_2);
  dst->set_fcw_inhibit_flag(src.fcw_inhibit_flag);
  dst->set_aeb_deactive_flag(src.aeb_deactive_flag);
  dst->set_fcw_deactive_flag(src.fcw_deactive_flag);
  dst->set_aeb_inhibit_override_flag(src.aeb_inhibit_override_flag);
  dst->set_fcw_inhibit_override_flag(src.fcw_inhibit_override_flag);
}

void Struct2Proto_AEB_DebugInfo(const AEB_DebugInfo& src, zpilot::AEB::proto::AEB_DebugInfo* dst) {
  for (const auto& struct_item : src.obj_data_info) {
      Struct2Proto_ObjDataInfo(struct_item, dst->add_obj_data_info());
   }
  Struct2Proto_EgoInfo(src.ego_info, dst->mutable_ego_info());
  Struct2Proto_PrimaryTargetIntvInfo(src.primary_target_intv_info, dst->mutable_primary_target_intv_info());
  Struct2Proto_PrimaryTargetWarnInfo(src.primary_target_warn_info, dst->mutable_primary_target_warn_info());
  Struct2Proto_RiskConditionInfo(src.risk_condition_info, dst->mutable_risk_condition_info());
  Struct2Proto_InhibitInfo(src.inhibit_info, dst->mutable_inhibit_info());
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::AEB::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_AEB_TAROBJ_BUS(const AEB_TAROBJ_BUS& src, zpilot::AEB::proto::AEB_TAROBJ_BUS* dst) {
  dst->set_primtarinpahnow(src.PrimTarInPahNow);
  dst->set_inpathpredict(src.InPathPredict);
  dst->set_fusiontype(src.FusionType);
  dst->set_objectindex(src.ObjectIndex);
  dst->set_objecttype(src.ObjectType);
  dst->set_objectmovingstate(src.ObjectMovingState);
  dst->set_objectmovingorientation(src.ObjectMovingOrientation);
  dst->set_objectlength(src.ObjectLength);
  dst->set_objectwidth(src.ObjectWidth);
  dst->set_objectyawangle(src.ObjectYawAngle);
  dst->set_object_rangex(src.Object_RangeX);
  dst->set_object_rangey(src.Object_RangeY);
  dst->set_object_abs_vx(src.Object_Abs_VX);
  dst->set_object_abs_vy(src.Object_Abs_VY);
  dst->set_object_abs_ax(src.Object_Abs_AX);
  dst->set_object_abs_ay(src.Object_Abs_AY);
  dst->set_titocllsn(src.TiToCllsn);
  dst->set_aneglgtrqrd(src.ANegLgtRqrd);
  dst->set_aneglgtrqrdforprimtarwarn(src.ANegLgtRqrdForPrimTarWarn);
  dst->set_crvtrqrdle(src.CrvtRqrdLe);
  dst->set_crvtrqrdri(src.CrvtRqrdRi);
  dst->set_alatrqrd(src.ALatRqrd);
  dst->set_objectid(src.ObjectID);
  dst->set_camid(src.camID);
}

void Struct2Proto_AEB_RECORDER_DATA(const AEB_RECORDER_DATA& src, zpilot::AEB::proto::AEB_RECORDER_DATA* dst) {
  dst->set_object_class(src.object_class);
  dst->set_object_status(src.object_status);
  dst->set_vxv_ref(src.vxv_ref);
  dst->set_axv_ref(src.axv_ref);
  dst->set_ayv_ref(src.ayv_ref);
  dst->set_dxv(src.dxv);
  dst->set_dyv(src.dyv);
  dst->set_vxv(src.vxv);
  dst->set_vyv(src.vyv);
  dst->set_axv(src.axv);
  dst->set_ayv(src.ayv);
  dst->set_d_width(src.d_width);
  dst->set_curve_rate(src.curve_rate);
  dst->set_aeb_inhibit_flag_1(src.aeb_inhibit_flag_1);
  dst->set_aeb_inhibit_flag_2(src.aeb_inhibit_flag_2);
}

void Struct2Proto_AEB_Measurement(const AEB_Measurement& src, zpilot::AEB::proto::AEB_Measurement* dst) {
  dst->set_aeb_safetyfunctionupdatecnt(src.AEB_SafetyFunctionUpdateCnt);
  dst->set_aeb_updatecnt(src.AEB_UpdateCnt);
  dst->set_aeb_safetyfunctionversion(src.AEB_SafetyFunctionVersion);
  dst->set_aeb_version(src.AEB_Version);
  dst->set_swcout_aeb_edrtype(src.SwcOut_AEB_EDRType);
  Struct2Proto_AEB_BRKINFO_BUS(src.SwcOut_AEB_BRKINFO, dst->mutable_swcout_aeb_brkinfo());
  Struct2Proto_AEB_TAROBJ_BUS(src.SwcOut_AEB_TAROBJ, dst->mutable_swcout_aeb_tarobj());
  Struct2Proto_AEB_RECORDER_DATA(src.SwcOut_AEB_RECORDER_DATA, dst->mutable_swcout_aeb_recorder_data());
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_AEB_Herbeat_Info, dst->mutable_swcout_aeb_herbeat_info());
  Struct2Proto_AEB_DebugInfo(src.SwcOut_AEB_DebugInfo, dst->mutable_swcout_aeb_debuginfo());
  dst->set_aeb_reserve01(src.AEB_reserve01);
  dst->set_aeb_reserve02(src.AEB_reserve02);
  dst->set_aeb_reserve03(src.AEB_reserve03);
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_J3_IHBC_ELEM_BUS(const J3_IHBC_ELEM_BUS& src, zpilot::j3_ihbc::proto::J3_IHBC_ELEM_BUS* dst) {
  dst->set_ihbc_obj_relevant_obs_id(src.IHBC_OBJ_RELEVANT_OBS_ID);
  dst->set_ihbc_obj_type(src.IHBC_OBJ_TYPE);
  dst->set_ihbc_obj_valid(src.IHBC_OBJ_VALID);
  dst->set_ihbc_obj_id(src.IHBC_OBJ_ID);
  dst->set_ihbc_coupled_width(src.IHBC_COUPLED_WIDTH);
  dst->set_ihbc_obj_pos_x(src.IHBC_OBJ_POS_X);
  dst->set_ihbc_obj_pos_y(src.IHBC_OBJ_POS_Y);
  dst->set_ihbc_obj_bottom_ang(src.IHBC_OBJ_BOTTOM_ANG);
  dst->set_ihbc_obj_left_ang(src.IHBC_OBJ_LEFT_ANG);
  dst->set_ihbc_obj_right_ang(src.IHBC_OBJ_RIGHT_ANG);
  dst->set_ihbc_obj_top_ang(src.IHBC_OBJ_TOP_ANG);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_ihbc::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_IHBC_HDR_BUS(const J3_IHBC_HDR_BUS& src, zpilot::j3_ihbc::proto::J3_IHBC_HDR_BUS* dst) {
  dst->set_ihbc_decision(src.IHBC_Decision);
  dst->set_ihbc_running_mode(src.IHBC_Running_Mode);
  dst->set_num_of_objects(src.Num_Of_Objects);
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_reason_oncoming(src.Reason_Oncoming);
  dst->set_reason_preceding(src.Reason_Preceding);
  dst->set_reason_street_light(src.Reason_Street_Light);
  dst->set_reason_for_ihbc_inactive(src.Reason_for_IHBC_Inactive);
  dst->set_rollingcounter_ihbc(src.RollingCounter_IHBC);
  dst->set_environment_lux(src.Environment_Lux);
  dst->set_environment_lux_recalculate(src.Environment_Lux_Recalculate);
  dst->set_crcchecksum_ihbc(src.CRCChecksum_IHBC);
}

void Struct2Proto_J3_IHBC_BUS(const J3_IHBC_BUS& src, zpilot::j3_ihbc::proto::J3_IHBC_BUS* dst) {
  Struct2Proto_J3_IHBC_HDR_BUS(src.J3_IHBC_HDR, dst->mutable_j3_ihbc_hdr());
  Struct2Proto_J3_SYNC_BUS(src.J3_IHBC_SYNC, dst->mutable_j3_ihbc_sync());
  for (const auto& struct_item : src.J3_IHBC_ELEM) {
      Struct2Proto_J3_IHBC_ELEM_BUS(struct_item, dst->add_j3_ihbc_elem());
   }
}

void Struct2Proto_J3_FS_ELEM_BUS(const J3_FS_ELEM_BUS& src, zpilot::j3_fs::proto::J3_FS_ELEM_BUS* dst) {
  dst->set_fs_type_point(src.FS_Type_Point);
  dst->set_fs_lateral(src.FS_lateral);
  dst->set_fs_longitudinal(src.FS_longitudinal);
}

void Struct2Proto_J3_FS_HDR_BUS(const J3_FS_HDR_BUS& src, zpilot::j3_fs::proto::J3_FS_HDR_BUS* dst) {
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_rollingcounter_freespace(src.RollingCounter_FreeSpace);
  dst->set_crcchecksum_freespace(src.CRCChecksum_FreeSpace);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_fs::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_FS_BUS(const J3_FS_BUS& src, zpilot::j3_fs::proto::J3_FS_BUS* dst) {
  Struct2Proto_J3_FS_HDR_BUS(src.J3_FS_HDR, dst->mutable_j3_fs_hdr());
  Struct2Proto_J3_SYNC_BUS(src.J3_FS_SYNC, dst->mutable_j3_fs_sync());
  for (const auto& struct_item : src.J3_FS_ELEM) {
      Struct2Proto_J3_FS_ELEM_BUS(struct_item, dst->add_j3_fs_elem());
   }
}

void Struct2Proto_LAS_STATE_BUS(const LAS_STATE_BUS& src, zpilot::LAS::proto::LAS_STATE_BUS* dst) {
  dst->set_ldpsts(src.LDPSts);
  dst->set_ldwsts(src.LDWSts);
  dst->set_elksts(src.ELKSts);
}

void Struct2Proto_LAS_CONTROL_BUS(const LAS_CONTROL_BUS& src, zpilot::LAS::proto::LAS_CONTROL_BUS* dst) {
  dst->set_valid(src.Valid);
  dst->set_a0(src.A0);
  dst->set_a1(src.A1);
  dst->set_a2(src.A2);
  dst->set_a3(src.A3);
  dst->set_range(src.Range);
}

void Struct2Proto_LAS_HMI_BUS(const LAS_HMI_BUS& src, zpilot::LAS::proto::LAS_HMI_BUS* dst) {
  dst->set_lka_warn(src.LKA_Warn);
  dst->set_elk_warn(src.ELK_Warn);
  dst->set_handsoffwarnlevel(src.HandsOffWarnLevel);
  dst->set_flwheldy(src.FLWhelDy);
  dst->set_frwheldy(src.FRWhelDy);
  dst->set_ldp_con_idle2readybit(src.LDP_Con_Idle2ReadyBit);
  dst->set_ldp_con_ready2activebit(src.LDP_Con_Ready2ActiveBit);
  dst->set_ldp_con_active2readybit(src.LDP_Con_Active2ReadyBit);
  dst->set_ldp_con_other2idlebit(src.LDP_Con_Other2IdleBit);
  dst->set_ldw_con_idle2readybit(src.LDW_Con_Idle2ReadyBit);
  dst->set_ldw_con_ready2activebit(src.LDW_Con_Ready2ActiveBit);
  dst->set_ldw_con_active2readybit(src.LDW_Con_Active2ReadyBit);
  dst->set_ldw_con_other2idlebit(src.LDW_Con_Other2IdleBit);
  dst->set_elk_con_idle2readybit(src.ELK_Con_Idle2ReadyBit);
  dst->set_elk_con_ready2activebit(src.ELk_Con_Ready2ActiveBit);
  dst->set_elk_con_active2readybit(src.ELK_Con_Active2ReadyBit);
  dst->set_elk_con_other2idlebit(src.ELK_Con_Other2IdleBit);
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::LAS::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_LAS_Measurement(const LAS_Measurement& src, zpilot::LAS::proto::LAS_Measurement* dst) {
  dst->set_las_elkstate(src.LAS_ELKState);
  dst->set_las_elk_active2ready(src.LAS_ELK_Active2Ready);
  dst->set_las_elk_centerstableflag_b(src.LAS_ELK_CenterStableFlag_b);
  dst->set_las_elk_dashlineinwarningflag(src.LAS_ELK_DashLineInWarningFlag);
  dst->set_las_elk_dashlinewarncount(src.LAS_ELK_DashLineWarnCount);
  dst->set_las_elk_dashlinewarnwcount(src.LAS_ELK_DashLineWarnwCount);
  dst->set_las_elk_epstqdegoverrideflag_b(src.LAS_ELK_EPSTqDegOverrideFlag_b);
  dst->set_las_elk_epstqdiffoverflag_b(src.LAS_ELK_EPSTqDiffOverFlag_b);
  dst->set_las_elk_epstqsameoverflag_b(src.LAS_ELK_EPSTqSameOverFlag_b);
  dst->set_las_elk_fileftintervention(src.LAS_ELK_FiLeftIntervention);
  dst->set_las_elk_fileftroadegeinter_b(src.LAS_ELK_FiLeftRoadEgeInter_b);
  dst->set_las_elk_firightintervention(src.LAS_ELK_FiRightIntervention);
  dst->set_las_elk_firightroadegeinter_b(src.LAS_ELK_FiRightRoadEgeInter_b);
  dst->set_las_elk_finalready2active(src.LAS_ELK_FinalReady2Active);
  dst->set_las_elk_idle2ready(src.LAS_ELK_Idle2Ready);
  dst->set_las_elk_loncomingmindykap(src.LAS_ELK_LOnComingMinDyKap);
  dst->set_las_elk_lovertakingmindykap(src.LAS_ELK_LOvertakingMinDyKap);
  dst->set_las_elk_lane_valid(src.LAS_ELK_Lane_valid);
  dst->set_las_elk_ldy(src.LAS_ELK_Ldy);
  dst->set_las_elk_leftdashlineinwarningflag(src.LAS_ELK_LeftDashLineInWarningFlag);
  dst->set_las_elk_leftegeinventionzone(src.LAS_ELK_LeftEgeInventionZone);
  dst->set_las_elk_leftend(src.LAS_ELK_LeftEnd);
  dst->set_las_elk_leftincrosslineflag_b(src.LAS_ELK_LeftInCrossLineFlag_b);
  dst->set_las_elk_leftintervention(src.LAS_ELK_LeftIntervention);
  dst->set_las_elk_leftlanechangereflag_b(src.LAS_ELK_LeftLaneChangeReFlag_b);
  dst->set_las_elk_leftoncoming2linemindy(src.LAS_ELK_LeftOnComing2LineMinDy);
  dst->set_las_elk_leftoncomingapproachflag_b(src.LAS_ELK_LeftOnComingApproachFlag_b);
  dst->set_las_elk_leftoncomingdyflag(src.LAS_ELK_LeftOnComingDyFlag);
  dst->set_las_elk_leftoncomingflag_b(src.LAS_ELK_LeftOnComingFlag_b);
  dst->set_las_elk_leftoncomingkapflag_b(src.LAS_ELK_LeftOnComingKapFlag_b);
  dst->set_las_elk_leftoncominglatdis(src.LAS_ELK_LeftOnComingLatDis);
  dst->set_las_elk_leftoncominglatdisflag(src.LAS_ELK_LeftOnComingLatDisFlag);
  dst->set_las_elk_leftoncominglatdisoffsetflag_b(src.LAS_ELK_LeftOnComingLatDisOffsetFlag_b);
  dst->set_las_elk_leftoncomingnokapflag_b(src.LAS_ELK_LeftOnComingNoKapFlag_b);
  dst->set_las_elk_leftoncomingobsflag(src.LAS_ELK_LeftOnComingObsFlag);
  dst->set_las_elk_leftoncomingttc(src.LAS_ELK_LeftOnComingTTC);
  dst->set_las_elk_leftoncomingttcflag(src.LAS_ELK_LeftOnComingTTCFlag);
  dst->set_las_elk_leftoutcrosslineflag_b(src.LAS_ELK_LeftOutCrossLineFlag_b);
  dst->set_las_elk_leftoverobjinareaflag_b(src.LAS_ELK_LeftOverObjInAreaFlag_b);
  dst->set_las_elk_leftovertaking2linemindy(src.LAS_ELK_LeftOvertaking2LineMinDy);
  dst->set_las_elk_leftovertakingapproachflag_b(src.LAS_ELK_LeftOvertakingApproachFlag_b);
  dst->set_las_elk_leftovertakingdyflag(src.LAS_ELK_LeftOvertakingDyFlag);
  dst->set_las_elk_leftovertakingflag_b(src.LAS_ELK_LeftOvertakingFlag_b);
  dst->set_las_elk_leftovertakingkapflag_b(src.LAS_ELK_LeftOvertakingKapFlag_b);
  dst->set_las_elk_leftovertakinglatdis(src.LAS_ELK_LeftOvertakingLatDis);
  dst->set_las_elk_leftovertakinglatdisoffsetflag_b(src.LAS_ELK_LeftOvertakingLatDisOffsetFlag_b);
  dst->set_las_elk_leftovertakinglatflag(src.LAS_ELK_LeftOvertakingLatFlag);
  dst->set_las_elk_leftovertakingnokapflag_b(src.LAS_ELK_LeftOvertakingNoKapFlag_b);
  dst->set_las_elk_leftovertakingttc(src.LAS_ELK_LeftOvertakingTTC);
  dst->set_las_elk_leftovertakingttc1(src.LAS_ELK_LeftOvertakingTTC1);
  dst->set_las_elk_leftovertakingttcflag(src.LAS_ELK_LeftOvertakingTTCFlag);
  dst->set_las_elk_leftroadegeinter_b(src.LAS_ELK_LeftRoadEgeInter_b);
  dst->set_las_elk_leftwarn(src.LAS_ELK_LeftWarn);
  dst->set_las_elk_leftout(src.LAS_ELK_Leftout);
  dst->set_las_elk_lineinterstate_st(src.LAS_ELK_LineInterState_st);
  dst->set_las_elk_lwidth_valid(src.LAS_ELK_Lwidth_Valid);
  dst->set_las_elk_oncomingflag_b(src.LAS_ELK_OnComingFlag_b);
  dst->set_las_elk_oncoming_lout_b(src.LAS_ELK_OnComing_LOut_b);
  dst->set_las_elk_oncoming_letfcondition_b(src.LAS_ELK_OnComing_LetfCondition_b);
  dst->set_las_elk_oncoming_rout_b(src.LAS_ELK_OnComing_ROut_b);
  dst->set_las_elk_oncoming_rightcondition_b(src.LAS_ELK_OnComing_RightCondition_b);
  dst->set_las_elk_other2idle(src.LAS_ELK_Other2Idle);
  dst->set_las_elk_overtaking_lout_b(src.LAS_ELK_OverTaking_LOut_b);
  dst->set_las_elk_overtaking_leftcondition_b(src.LAS_ELK_OverTaking_LeftCondition_b);
  dst->set_las_elk_overtaking_rout_b(src.LAS_ELK_OverTaking_ROut_b);
  dst->set_las_elk_overtaking_rightcondition_b(src.LAS_ELK_OverTaking_RightCondition_b);
  dst->set_las_elk_overtakingflag_b(src.LAS_ELK_OvertakingFlag_b);
  dst->set_las_elk_roncomingmindykap(src.LAS_ELK_ROnComingMinDyKap);
  dst->set_las_elk_rdy(src.LAS_ELK_Rdy);
  dst->set_las_elk_ready2active(src.LAS_ELK_Ready2Active);
  dst->set_las_elk_riincrosslineflag_b(src.LAS_ELK_RiInCrossLineFlag_b);
  dst->set_las_elk_rilanechangereflag_b(src.LAS_ELK_RiLaneChangeReFlag_b);
  dst->set_las_elk_rioncomingapproachflag_b(src.LAS_ELK_RiOnComingApproachFlag_b);
  dst->set_las_elk_rioncominglatdisoffsetflag_b(src.LAS_ELK_RiOnComingLatDisOffsetFlag_b);
  dst->set_las_elk_rioutcrosslineflag_b(src.LAS_ELK_RiOutCrossLineFlag_b);
  dst->set_las_elk_riovertakingapproachflag_b(src.LAS_ELK_RiOvertakingApproachFlag_b);
  dst->set_las_elk_riovertakinglatdisoffsetflag_b(src.LAS_ELK_RiOvertakingLatDisOffsetFlag_b);
  dst->set_las_elk_rightdashlineinwarningflag(src.LAS_ELK_RightDashLineInWarningFlag);
  dst->set_las_elk_rightegeinventionzone(src.LAS_ELK_RightEgeInventionZone);
  dst->set_las_elk_rightintervention(src.LAS_ELK_RightIntervention);
  dst->set_las_elk_rightinterventionend(src.LAS_ELK_RightInterventionEnd);
  dst->set_las_elk_rightoncoming2linemindy(src.LAS_ELK_RightOnComing2LineMinDy);
  dst->set_las_elk_rightoncomingdyflag(src.LAS_ELK_RightOnComingDyFlag);
  dst->set_las_elk_rightoncomingflag_b(src.LAS_ELK_RightOnComingFlag_b);
  dst->set_las_elk_rightoncomingkapflag_b(src.LAS_ELK_RightOnComingKapFlag_b);
  dst->set_las_elk_rightoncominglatdis(src.LAS_ELK_RightOnComingLatDis);
  dst->set_las_elk_rightoncominglatdisflag(src.LAS_ELK_RightOnComingLatDisFlag);
  dst->set_las_elk_rightoncomingnokapflag_b(src.LAS_ELK_RightOnComingNoKapFlag_b);
  dst->set_las_elk_rightoncomingobsflag(src.LAS_ELK_RightOnComingObsFlag);
  dst->set_las_elk_rightoncomingttc(src.LAS_ELK_RightOnComingTTC);
  dst->set_las_elk_rightoncomingttcflag(src.LAS_ELK_RightOnComingTTCFlag);
  dst->set_las_elk_rightoverobjinareaflag_b(src.LAS_ELK_RightOverObjInAreaFlag_b);
  dst->set_las_elk_rightovertaking2linemindy(src.LAS_ELK_RightOvertaking2LineMinDy);
  dst->set_las_elk_rightovertakingdyflag(src.LAS_ELK_RightOvertakingDyFlag);
  dst->set_las_elk_rightovertakingflag_b(src.LAS_ELK_RightOvertakingFlag_b);
  dst->set_las_elk_rightovertakingkapflag_b(src.LAS_ELK_RightOvertakingKapFlag_b);
  dst->set_las_elk_rightovertakinglatdis(src.LAS_ELK_RightOvertakingLatDis);
  dst->set_las_elk_rightovertakinglatdiskap(src.LAS_ELK_RightOvertakingLatDisKap);
  dst->set_las_elk_rightovertakinglatflag(src.LAS_ELK_RightOvertakingLatFlag);
  dst->set_las_elk_rightovertakingnokapflag_b(src.LAS_ELK_RightOvertakingNoKapFlag_b);
  dst->set_las_elk_rightovertakingttc(src.LAS_ELK_RightOvertakingTTC);
  dst->set_las_elk_rightovertakingttc1(src.LAS_ELK_RightOvertakingTTC1);
  dst->set_las_elk_rightovertakingttcflag(src.LAS_ELK_RightOvertakingTTCFlag);
  dst->set_las_elk_rightroadegeinter_b(src.LAS_ELK_RightRoadEgeInter_b);
  dst->set_las_elk_rightwarn(src.LAS_ELK_RightWarn);
  dst->set_las_elk_rightout(src.LAS_ELK_Rightout);
  dst->set_las_elk_roadegeinterstate_st(src.LAS_ELK_RoadEgeInterState_st);
  dst->set_las_elk_roadwidth(src.LAS_ELK_RoadWidth);
  dst->set_las_elk_vehconfigelk(src.LAS_ELK_VehConfigELK);
  dst->set_las_elk_warning(src.LAS_ELK_Warning);
  dst->set_las_elk_incount(src.LAS_ELK_incount);
  dst->set_las_elk_wcount(src.LAS_ELK_wcount);
  dst->set_las_flegedy(src.LAS_FLEgeDy);
  dst->set_las_flwheldy(src.LAS_FLWhelDy);
  dst->set_las_fregedy(src.LAS_FREgeDy);
  dst->set_las_frwheldy(src.LAS_FRWhelDy);
  dst->set_las_ldwsts(src.LAS_LDWSts);
  dst->set_las_ldw_active2ready(src.LAS_LDW_Active2Ready);
  dst->set_las_ldw_count(src.LAS_LDW_Count);
  dst->set_las_ldw_counter(src.LAS_LDW_Counter);
  dst->set_las_ldw_error(src.LAS_LDW_Error);
  dst->set_las_ldw_idle2ready(src.LAS_LDW_Idle2Ready);
  dst->set_las_ldw_ldy(src.LAS_LDW_Ldy);
  dst->set_las_ldw_leftincrosslineflag_b(src.LAS_LDW_LeftInCrossLineFlag_b);
  dst->set_las_ldw_leftlanechangereflag_b(src.LAS_LDW_LeftLaneChangeReFlag_b);
  dst->set_las_ldw_leftoutcrosslineflag_b(src.LAS_LDW_LeftOutCrossLineFlag_b);
  dst->set_las_ldw_leftshiledsolidwarnflag(src.LAS_LDW_LeftShiledSolidWarnFlag);
  dst->set_las_ldw_leftwarnflag(src.LAS_LDW_Leftwarnflag);
  dst->set_las_ldw_other2idle(src.LAS_LDW_Other2Idle);
  dst->set_las_ldw_rdy(src.LAS_LDW_Rdy);
  dst->set_las_ldw_ready2active(src.LAS_LDW_Ready2Active);
  dst->set_las_ldw_riincrosslineflag_b(src.LAS_LDW_RiInCrossLineFlag_b);
  dst->set_las_ldw_rilanechangereflag_b(src.LAS_LDW_RiLaneChangeReFlag_b);
  dst->set_las_ldw_rioutcrosslineflag_b(src.LAS_LDW_RiOutCrossLineFlag_b);
  dst->set_las_ldw_rightshiledsolidwarnflag(src.LAS_LDW_RightShiledSolidWarnFlag);
  dst->set_las_ldw_rightwarnflag(src.LAS_LDW_Rightwarnflag);
  dst->set_las_ldw_vehconfigldw(src.LAS_LDW_VehConfigLDW);
  dst->set_las_ldw_wcount(src.LAS_LDW_wCount);
  dst->set_las_lkastate(src.LAS_LKAState);
  dst->set_las_lka_epstqdegoverrideflag_b(src.LAS_LKA_EPSTqDegOverrideFlag_b);
  dst->set_las_lka_epstqdiffoverflag_b(src.LAS_LKA_EPSTqDiffOverFlag_b);
  dst->set_las_lka_epstqsameoverflag_b(src.LAS_LKA_EPSTqSameOverFlag_b);
  dst->set_las_lka_error(src.LAS_LKA_Error);
  dst->set_las_lka_fileftintervention(src.LAS_LKA_FiLeftIntervention);
  dst->set_las_lka_firightintervention(src.LAS_LKA_FiRightIntervention);
  dst->set_las_lka_finalready2active(src.LAS_LKA_FinalReady2Active);
  dst->set_las_lka_ldy(src.LAS_LKA_Ldy);
  dst->set_las_lka_leftincrosslineflag_b(src.LAS_LKA_LeftInCrossLineFlag_b);
  dst->set_las_lka_leftintervention(src.LAS_LKA_LeftIntervention);
  dst->set_las_lka_leftinterventionend(src.LAS_LKA_LeftInterventionEnd);
  dst->set_las_lka_leftlanechangereflag_b(src.LAS_LKA_LeftLaneChangeReFlag_b);
  dst->set_las_lka_leftoutcrosslineflag_b(src.LAS_LKA_LeftOutCrossLineFlag_b);
  dst->set_las_lka_leftwarning(src.LAS_LKA_LeftWarning);
  dst->set_las_lka_leftout(src.LAS_LKA_Leftout);
  dst->set_las_lka_rdy(src.LAS_LKA_Rdy);
  dst->set_las_lka_riincrosslineflag_b(src.LAS_LKA_RiInCrossLineFlag_b);
  dst->set_las_lka_rilanechangereflag_b(src.LAS_LKA_RiLaneChangeReFlag_b);
  dst->set_las_lka_rioutcrosslineflag_b(src.LAS_LKA_RiOutCrossLineFlag_b);
  dst->set_las_lka_rightintervention(src.LAS_LKA_RightIntervention);
  dst->set_las_lka_rightinterventionend(src.LAS_LKA_RightInterventionEnd);
  dst->set_las_lka_rightwarning(src.LAS_LKA_RightWarning);
  dst->set_las_lka_rightout(src.LAS_LKA_Rightout);
  dst->set_las_lka_vehconfiglka(src.LAS_LKA_VehConfigLKA);
  dst->set_las_lka_warning(src.LAS_LKA_Warning);
  dst->set_las_reserve0(src.LAS_Reserve0);
  dst->set_las_reserve1(src.LAS_Reserve1);
  dst->set_las_reserve2(src.LAS_Reserve2);
  dst->set_las_reserve3(src.LAS_Reserve3);
  dst->set_las_reserve4(src.LAS_Reserve4);
  dst->set_las_reserve5(src.LAS_Reserve5);
  dst->set_las_reserve6(src.LAS_Reserve6);
  dst->set_las_reserve7(src.LAS_Reserve7);
  dst->set_las_reserve8(src.LAS_Reserve8);
  dst->set_las_reserve9(src.LAS_Reserve9);
  dst->set_las_scm_centerlanewidth(src.LAS_SCM_CenterLaneWidth);
  dst->set_las_scm_centerlinea0(src.LAS_SCM_CenterLineA0);
  dst->set_las_scm_centerlinea1(src.LAS_SCM_CenterLineA1);
  dst->set_las_scm_centerlinea2(src.LAS_SCM_CenterLineA2);
  dst->set_las_scm_centerlinea3(src.LAS_SCM_CenterLineA3);
  dst->set_las_scm_centerlinelength(src.LAS_SCM_CenterLineLength);
  dst->set_las_scm_centerlinevalid(src.LAS_SCM_CenterLineValid);
  dst->set_las_scm_flwhel2rilinedy(src.LAS_SCM_FLWhel2RiLineDy);
  dst->set_las_scm_frwhel2leftlinedy(src.LAS_SCM_FRWhel2LeftLineDy);
  dst->set_las_scm_frontroadnorepaireflag(src.LAS_SCM_FrontRoadNoRepaireFlag);
  dst->set_las_scm_headingangin_b(src.LAS_SCM_HeadingAngIn_b);
  dst->set_las_scm_headingangout_b(src.LAS_SCM_HeadingAngOut_b);
  dst->set_las_scm_lanewidth_m(src.LAS_SCM_LaneWidth_m);
  dst->set_las_scm_leftchange_b(src.LAS_SCM_LeftChange_b);
  dst->set_las_scm_leftedglinenear_b(src.LAS_SCM_LeftEdgLineNear_b);
  dst->set_las_scm_leftegepathchange_b(src.LAS_SCM_LeftEgePathChange_b);
  dst->set_las_scm_leftegestd_b(src.LAS_SCM_LeftEgeStd_b);
  dst->set_las_scm_leftlanenear_b(src.LAS_SCM_LeftLaneNear_b);
  dst->set_las_scm_leftlinepathchange_b(src.LAS_SCM_LeftLinePathChange_b);
  dst->set_las_scm_leftlinestd_b(src.LAS_SCM_LeftLineStd_b);
  dst->set_las_scm_number(src.LAS_SCM_Number);
  dst->set_las_scm_rightchange_b(src.LAS_SCM_RightChange_b);
  dst->set_las_scm_rightedglinenear_b(src.LAS_SCM_RightEdgLineNear_b);
  dst->set_las_scm_rightegepathchange_b(src.LAS_SCM_RightEgePathChange_b);
  dst->set_las_scm_rightegestd_b(src.LAS_SCM_RightEgeStd_b);
  dst->set_las_scm_rightlanenear_b(src.LAS_SCM_RightLaneNear_b);
  dst->set_las_scm_rightlinepathchange_b(src.LAS_SCM_RightLinePathChange_b);
  dst->set_las_scm_rightlinestd_b(src.LAS_SCM_RightLineStd_b);
  dst->set_las_scm_vehnearlorrline_st(src.LAS_SCM_VehNearLOrRLine_st);
  dst->set_las_scm_repaireroaddistance(src.LAS_SCM_repaireRoadDistance);
  dst->set_las_updatecnt(src.LAS_UpdateCnt);
  dst->set_las_version(src.LAS_Version);
  dst->set_las_preflwheldy(src.LAS_preFLWhelDy);
  dst->set_las_prefrwheldy(src.LAS_preFRWhelDy);
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_LAS_Herbeat_info, dst->mutable_swcout_las_herbeat_info());
  Struct2Proto_LAS_CONTROL_BUS(src.SwcOut_LAS_CTRL, dst->mutable_swcout_las_ctrl());
  Struct2Proto_LAS_HMI_BUS(src.SwcOut_LAS_HMI, dst->mutable_swcout_las_hmi());
  Struct2Proto_LAS_STATE_BUS(src.SwcOut_LAS_STATE, dst->mutable_swcout_las_state());
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_tfl::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_TFL_HDR_BUS(const J3_TFL_HDR_BUS& src, zpilot::j3_tfl::proto::J3_TFL_HDR_BUS* dst) {
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_tflmainobjectid(src.TFLMainObjectID);
  dst->set_tflobjectsnumber(src.TFLObjectsNumber);
  dst->set_rollingcounter_tsrtfl(src.RollingCounter_TSRTFL);
  dst->set_crcchecksum_tsrtfl(src.CRCChecksum_TSRTFL);
}

void Struct2Proto_J3_TFL_ELEM_BUS(const J3_TFL_ELEM_BUS& src, zpilot::j3_tfl::proto::J3_TFL_ELEM_BUS* dst) {
  dst->set_tfl_confidence(src.TFL_Confidence);
  dst->set_tfl_id(src.TFL_ID);
  dst->set_tfl_shapetype(src.TFL_ShapeType);
  dst->set_tfl_bulb_color_1(src.TFL_Bulb_Color_1);
  dst->set_tfl_bulb_color_2(src.TFL_Bulb_Color_2);
  dst->set_tfl_bulb_color_3(src.TFL_Bulb_Color_3);
  dst->set_tfl_classificationtype_1(src.TFL_ClassificationType_1);
  dst->set_tfl_classificationtype_2(src.TFL_ClassificationType_2);
  dst->set_tfl_classificationtype_3(src.TFL_ClassificationType_3);
  dst->set_is_tfl_blinking_1(src.is_TFL_Blinking_1);
  dst->set_is_tfl_blinking_2(src.is_TFL_Blinking_2);
  dst->set_is_tfl_blinking_3(src.is_TFL_Blinking_3);
  dst->set_tfl_posx(src.TFL_PosX);
  dst->set_tfl_posy(src.TFL_PosY);
  dst->set_tfl_posz(src.TFL_PosZ);
  dst->set_tfl_width(src.TFL_Width);
  dst->set_tfl_internal_id(src.TFL_Internal_ID);
}

void Struct2Proto_J3_TFL_BUS(const J3_TFL_BUS& src, zpilot::j3_tfl::proto::J3_TFL_BUS* dst) {
  Struct2Proto_J3_SYNC_BUS(src.J3_TFL_SYNC, dst->mutable_j3_tfl_sync());
  Struct2Proto_J3_TFL_HDR_BUS(src.J3_TFL_HDR, dst->mutable_j3_tfl_hdr());
  for (const auto& struct_item : src.J3_TFL_ELEM) {
      Struct2Proto_J3_TFL_ELEM_BUS(struct_item, dst->add_j3_tfl_elem());
   }
}

void Struct2Proto_Position_BUS(const Position_BUS& src, zpilot::VMC::proto::Position_BUS* dst) {
  dst->set_x(src.x);
  dst->set_y(src.y);
  dst->set_heading_angle(src.heading_angle);
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::VMC::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_VMC_LGT_BUS(const VMC_LGT_BUS& src, zpilot::VMC::proto::VMC_LGT_BUS* dst) {
  dst->set_trq_req_active(src.trq_req_active);
  dst->set_decel_acc_req(src.decel_acc_req);
  dst->set_drv_off(src.drv_off);
  dst->set_dec_to_stop(src.dec_to_stop);
  dst->set_acc_mode(src.acc_mode);
  dst->set_brk_perfer(src.brk_perfer);
  dst->set_dc_ec_sts(src.dc_ec_sts);
  dst->set_max_jerk(src.max_jerk);
  dst->set_min_jerk(src.min_jerk);
  dst->set_comfort_low(src.comfort_low);
  dst->set_comfort_up(src.comfort_up);
  dst->set_tar_accel(src.tar_accel);
  dst->set_trq_req_value(src.trq_req_value);
  dst->set_decel_acc_req_value(src.decel_acc_req_value);
}

void Struct2Proto_VMC_LAT_BUS(const VMC_LAT_BUS& src, zpilot::VMC::proto::VMC_LAT_BUS* dst) {
  dst->set_trq_cmd_req(src.trq_cmd_req);
  dst->set_ang_cmd_req(src.ang_cmd_req);
  dst->set_trq_cmd_req_value(src.trq_cmd_req_value);
  dst->set_ang_cmd_req_value(src.ang_cmd_req_value);
  dst->set_steer_max_trq_req(src.steer_max_trq_req);
  dst->set_steer_min_trq_req(src.steer_min_trq_req);
  dst->set_latc_effect(src.latc_effect);
  for (const auto& struct_item : src.aim_point_xy) {
      dst->add_aim_point_xy(struct_item);
   }
}

void Struct2Proto_VMC_Measurement(const VMC_Measurement& src, zpilot::VMC::proto::VMC_Measurement* dst) {
  dst->set_vmc_version(src.VMC_Version);
  dst->set_vmc_updatecnt(src.VMC_UpdateCnt);
  dst->set_latc_offsetupdate_flg(src.LATC_OffSetUpdate_Flg);
  dst->set_latc_effect1(src.LATC_Effect1);
  dst->set_latc_angleslope_flg(src.LATC_AngleSlope_Flg);
  dst->set_latc_angclccnt(src.LATC_AngClcCnt);
  dst->set_latc_ackconstvalue(src.LATC_AckConstValue);
  dst->set_latc_psidtackvalue(src.LATC_PsiDtAckValue);
  dst->set_latc_currentsteerangleoffset_deg(src.LATC_CurrentSteerAngleOffset_deg);
  dst->set_latc_vie_steerangoffset_deg(src.LATC_VIE_SteerAngOffset_deg);
  dst->set_latc_in_steerangoffset_deg(src.LATC_IN_SteerAngOffset_deg);
  dst->set_latc_lastpointwithtarlanedis(src.LATC_LastPointWithTarLaneDis);
  dst->set_latc_lc_nomalpredis(src.LATC_LC_NomalPredis);
  dst->set_latc_lc_nomalpredisfac(src.LATC_LC_NomalPredisFac);
  dst->set_latc_lc_sportpredis(src.LATC_LC_SportPredis);
  dst->set_latc_lc_sportpredisfac(src.LATC_LC_SportPredisFac);
  dst->set_latc_predis_basedis(src.LATC_Predis_BaseDis);
  dst->set_latc_elkpredis(src.LATC_ELKPredis);
  dst->set_latc_elkpredisfac(src.LATC_ELKPredisFac);
  dst->set_latc_lkapredis(src.LATC_LKAPredis);
  dst->set_latc_lkapredisfac(src.LATC_LKAPredisFac);
  dst->set_latc_lckpredis(src.LATC_LCKPredis);
  dst->set_latc_lckpredisfac(src.LATC_LCKPredisFac);
  dst->set_latc_predis_curve(src.LATC_Predis_Curve);
  dst->set_latc_predis_curvefac(src.LATC_Predis_CurveFac);
  dst->set_latc_cursteerangle_deg(src.LATC_CurSteerAngle_deg);
  dst->set_latc_state_angleslope(src.LATC_State_AngleSlope);
  dst->set_latc_lc_complete_predisfac(src.LATC_LC_Complete_PreDisFac);
  dst->set_latc_stateactive_angleslope(src.LATC_StateActive_AngleSlope);
  dst->set_latc_stateactive_minangleslope(src.LATC_StateActive_MinAngleSlope);
  dst->set_latc_tarsteerangleslope(src.LATC_TarSteerAngleSlope);
  dst->set_latc_tarsteeranglecala(src.LATC_TarSteerAnglecala);
  dst->set_latc_tarsteerangleend(src.LATC_TarSteerAngleEnd);
  dst->set_latc_deltaangle(src.LATC_DeltaAngle);
  dst->set_latc_tarsteerangle_filtertime(src.LATC_TarSteerAngle_FilterTime);
  dst->set_latc_tarsteerangle_addoffset(src.LATC_TarSteerAngle_Addoffset);
  dst->set_latc_q(src.LATC_Q);
  dst->set_latc_finalpredis(src.LATC_finalPredis);
  for (const auto& struct_item : src.LATC_Poly_vec) {
      dst->add_latc_poly_vec(struct_item);
   }
  dst->set_latc_dangerlevel(src.LATC_DangerLevel);
  for (const auto& struct_item : src.LATC_TarSteerAngleCalc_XX) {
      dst->add_latc_tarsteeranglecalc_xx(struct_item);
   }
  for (const auto& struct_item : src.LATC_TarSteerAngleCalc_YY) {
      dst->add_latc_tarsteeranglecalc_yy(struct_item);
   }
  dst->set_latc_tarangle_maxang(src.LATC_TarAngle_MaxAng);
  dst->set_latc_tarangle_maxangspd(src.LATC_TarAngle_MaxAngSpd);
  Struct2Proto_Position_BUS(src.SwcOut_VMC_EXEC_POS, dst->mutable_swcout_vmc_exec_pos());
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_VMC_Herbeat_Info, dst->mutable_swcout_vmc_herbeat_info());
  Struct2Proto_VMC_LGT_BUS(src.SwcOut_VMC_LGT, dst->mutable_swcout_vmc_lgt());
  Struct2Proto_VMC_LAT_BUS(src.SwcOut_VMC_LAT, dst->mutable_swcout_vmc_lat());
  for (const auto& struct_item : src.VMC_reserve) {
      dst->add_vmc_reserve(struct_item);
   }
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_J3_TFC_ELEM_BUS(const J3_TFC_ELEM_BUS& src, zpilot::j3_tfc::proto::J3_TFC_ELEM_BUS* dst) {
  dst->set_tfc_confidence(src.TFC_Confidence);
  dst->set_tfc_id(src.TFC_ID);
  dst->set_tfc_relevancy(src.TFC_Relevancy);
  dst->set_tfc_type(src.TFC_Type);
  dst->set_tfc_length(src.TFC_Length);
  dst->set_tfc_position_x(src.TFC_Position_X);
  dst->set_tfc_position_y(src.TFC_Position_Y);
  dst->set_tfc_width(src.TFC_Width);
  dst->set_tfc_internal_id(src.TFC_Internal_ID);
}

void Struct2Proto_J3_TFC_HDR_BUS(const J3_TFC_HDR_BUS& src, zpilot::j3_tfc::proto::J3_TFC_HDR_BUS* dst) {
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_tfcobjectsnumber(src.TFCObjectsNumber);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_tfc::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_TFC_BUS(const J3_TFC_BUS& src, zpilot::j3_tfc::proto::J3_TFC_BUS* dst) {
  Struct2Proto_J3_SYNC_BUS(src.J3_TFC_SYNC, dst->mutable_j3_tfc_sync());
  Struct2Proto_J3_TFC_HDR_BUS(src.J3_TFC_HDR, dst->mutable_j3_tfc_hdr());
  for (const auto& struct_item : src.J3_TFC_ELEM) {
      Struct2Proto_J3_TFC_ELEM_BUS(struct_item, dst->add_j3_tfc_elem());
   }
}

void Struct2Proto_TOS_ACC_BUS(const TOS_ACC_BUS& src, zpilot::TOS::proto::TOS_ACC_BUS* dst) {
  dst->set_targetexist(src.targetExist);
  dst->set_cutinflg(src.cutInflg);
  dst->set_brakeintention(src.brakeIntention);
  dst->set_movingstate(src.movingState);
  dst->set_orientation(src.orientation);
  dst->set_type(src.type);
  dst->set_fu_type(src.fu_type);
  dst->set_dx(src.dx);
  dst->set_dy(src.dy);
  dst->set_vxrel(src.vxRel);
  dst->set_vyrel(src.vyRel);
  dst->set_vxabs(src.vxAbs);
  dst->set_vyabs(src.vyAbs);
  dst->set_axabs(src.axAbs);
  dst->set_ayabs(src.ayAbs);
  dst->set_range(src.range);
  dst->set_objexist(src.objExist);
  dst->set_headingangle(src.headingAngle);
  dst->set_object_length(src.Object_Length);
  dst->set_object_width(src.Object_Width);
  dst->set_object_hight(src.Object_Hight);
  dst->set_id(src.id);
  dst->set_age(src.age);
}

void Struct2Proto_TOS_HWA_BUS(const TOS_HWA_BUS& src, zpilot::TOS::proto::TOS_HWA_BUS* dst) {
  for (const auto& struct_item : src.LeftLane_flag) {
      dst->add_leftlane_flag(struct_item);
   }
  for (const auto& struct_item : src.SameLane_flag) {
      dst->add_samelane_flag(struct_item);
   }
  for (const auto& struct_item : src.RightLane_flag) {
      dst->add_rightlane_flag(struct_item);
   }
  for (const auto& struct_item : src.Object_Type) {
      dst->add_object_type(struct_item);
   }
  for (const auto& struct_item : src.Object_MovingState) {
      dst->add_object_movingstate(struct_item);
   }
  for (const auto& struct_item : src.Object_Orientation) {
      dst->add_object_orientation(struct_item);
   }
  for (const auto& struct_item : src.Object_Turn_Signal) {
      dst->add_object_turn_signal(struct_item);
   }
  for (const auto& struct_item : src.Object_Fus_Type) {
      dst->add_object_fus_type(struct_item);
   }
  for (const auto& struct_item : src.Object_Length) {
      dst->add_object_length(struct_item);
   }
  for (const auto& struct_item : src.Object_Width) {
      dst->add_object_width(struct_item);
   }
  for (const auto& struct_item : src.Object_Hight) {
      dst->add_object_hight(struct_item);
   }
  for (const auto& struct_item : src.Object_HeadingAngle) {
      dst->add_object_headingangle(struct_item);
   }
  for (const auto& struct_item : src.Object_YawAngle) {
      dst->add_object_yawangle(struct_item);
   }
  for (const auto& struct_item : src.Object_DX) {
      dst->add_object_dx(struct_item);
   }
  for (const auto& struct_item : src.Object_DY) {
      dst->add_object_dy(struct_item);
   }
  for (const auto& struct_item : src.Object_VX) {
      dst->add_object_vx(struct_item);
   }
  for (const auto& struct_item : src.Object_VY) {
      dst->add_object_vy(struct_item);
   }
  for (const auto& struct_item : src.Object_Abs_VX) {
      dst->add_object_abs_vx(struct_item);
   }
  for (const auto& struct_item : src.Object_Abs_VY) {
      dst->add_object_abs_vy(struct_item);
   }
  for (const auto& struct_item : src.Object_Abs_AX) {
      dst->add_object_abs_ax(struct_item);
   }
  for (const auto& struct_item : src.Object_Abs_AY) {
      dst->add_object_abs_ay(struct_item);
   }
  for (const auto& struct_item : src.corner_left_front_x) {
      dst->add_corner_left_front_x(struct_item);
   }
  for (const auto& struct_item : src.corner_left_front_y) {
      dst->add_corner_left_front_y(struct_item);
   }
  for (const auto& struct_item : src.corner_right_front_x) {
      dst->add_corner_right_front_x(struct_item);
   }
  for (const auto& struct_item : src.corner_right_front_y) {
      dst->add_corner_right_front_y(struct_item);
   }
  for (const auto& struct_item : src.corner_left_rear_x) {
      dst->add_corner_left_rear_x(struct_item);
   }
  for (const auto& struct_item : src.corner_left_rear_y) {
      dst->add_corner_left_rear_y(struct_item);
   }
  for (const auto& struct_item : src.corner_right_rear_x) {
      dst->add_corner_right_rear_x(struct_item);
   }
  for (const auto& struct_item : src.corner_right_rear_y) {
      dst->add_corner_right_rear_y(struct_item);
   }
  for (const auto& struct_item : src.Object_ID) {
      dst->add_object_id(struct_item);
   }
  for (const auto& struct_item : src.Object_Age) {
      dst->add_object_age(struct_item);
   }
}

void Struct2Proto_LINE_BUS(const LINE_BUS& src, zpilot::TOS::proto::LINE_BUS* dst) {
  dst->set_source(src.Source);
  dst->set_bislineexist(src.bIsLineExist);
  dst->set_dc0v(src.dC0V);
  dst->set_dc1v(src.dC1V);
  dst->set_dc2v(src.dC2V);
  dst->set_dc3v(src.dC3V);
  dst->set_dc4v(src.dC4V);
  dst->set_dc5v(src.dC5V);
  dst->set_elinetype(src.eLineType);
  dst->set_ddisstart(src.dDisStart);
  dst->set_ddisfront(src.dDisFront);
  dst->set_dquality(src.dQuality);
  dst->set_dlanewidth(src.dLaneWidth);
  dst->set_elinefustype(src.eLinefusType);
}

void Struct2Proto_TOS_LM_TRAJINFO_BUS(const TOS_LM_TRAJINFO_BUS& src, zpilot::TOS::proto::TOS_LM_TRAJINFO_BUS* dst) {
  dst->set_pc0(src.pC0);
  dst->set_pc1(src.pC1);
  dst->set_pc2(src.pC2);
  dst->set_pc3(src.pC3);
  dst->set_pc4(src.pC4);
  dst->set_pc5(src.pC5);
  dst->set_ddisstart(src.dDisStart);
  dst->set_ddisend(src.dDisEnd);
  dst->set_dquality(src.dQuality);
  dst->set_fcamvalid(src.fCamValid);
}

void Struct2Proto_Lc_Sts(const Lc_Sts& src, zpilot::TOS::proto::Lc_Sts* dst) {
  dst->set_lc(src.Lc);
  dst->set_lc_left(src.LC_Left);
  dst->set_lc_right(src.LC_Right);
}

void Struct2Proto_TOS_AEB_BUS(const TOS_AEB_BUS& src, zpilot::TOS::proto::TOS_AEB_BUS* dst) {
  dst->set_leftlane_flag(src.LeftLane_flag);
  dst->set_samelane_flag(src.SameLane_flag);
  dst->set_rightlane_flag(src.RightLane_flag);
  dst->set_object_type(src.Object_Type);
  dst->set_object_movingstate(src.Object_MovingState);
  dst->set_object_orientation(src.Object_Orientation);
  dst->set_object_turn_signal(src.Object_Turn_Signal);
  dst->set_sceniaro_flag(src.Sceniaro_Flag);
  dst->set_cllsnmtgtnbybrkgprimqly(src.CllsnMtgtnByBrkgPrimQly);
  dst->set_cllsnmtgtnbybrkgsecqly(src.CllsnMtgtnByBrkgSecQly);
  dst->set_cllsnwarnfwdqly(src.CllsnWarnFwdQly);
  dst->set_ramp(src.ramp);
  dst->set_object_fus_type(src.Object_Fus_Type);
  dst->set_pro_flag(src.pro_flag);
  dst->set_object_length(src.Object_Length);
  dst->set_object_width(src.Object_Width);
  dst->set_object_hight(src.Object_Hight);
  dst->set_object_headingangle(src.Object_HeadingAngle);
  dst->set_object_yawangle(src.Object_YawAngle);
  dst->set_object_dx(src.Object_DX);
  dst->set_object_dy(src.Object_DY);
  dst->set_object_rangex(src.Object_RangeX);
  dst->set_object_rangey(src.Object_RangeY);
  dst->set_object_vx(src.Object_VX);
  dst->set_object_vy(src.Object_VY);
  dst->set_object_abs_speed(src.Object_Abs_SPEED);
  dst->set_object_abs_vx(src.Object_Abs_VX);
  dst->set_object_abs_vy(src.Object_Abs_VY);
  dst->set_object_ax(src.Object_AX);
  dst->set_object_ay(src.Object_AY);
  dst->set_object_abs_ax(src.Object_Abs_AX);
  dst->set_object_abs_ay(src.Object_Abs_AY);
  dst->set_corner_left_front_x(src.corner_left_front_x);
  dst->set_corner_left_front_y(src.corner_left_front_y);
  dst->set_corner_right_front_x(src.corner_right_front_x);
  dst->set_corner_right_front_y(src.corner_right_front_y);
  dst->set_corner_left_rear_x(src.corner_left_rear_x);
  dst->set_corner_left_rear_y(src.corner_left_rear_y);
  dst->set_corner_right_rear_x(src.corner_right_rear_x);
  dst->set_corner_right_rear_y(src.corner_right_rear_y);
  dst->set_object_id(src.Object_ID);
  dst->set_camid(src.camID);
  dst->set_object_age(src.Object_Age);
  dst->set_timestamp(src.TimeStamp);
}

void Struct2Proto_Poly_BUS(const Poly_BUS& src, zpilot::TOS::proto::Poly_BUS* dst) {
  dst->set_start(src.start);
  dst->set_end(src.end);
  for (const auto& struct_item : src.poly_vec) {
      dst->add_poly_vec(struct_item);
   }
}

void Struct2Proto_Refline_BUS(const Refline_BUS& src, zpilot::TOS::proto::Refline_BUS* dst) {
  dst->set_ref_source(src.ref_source);
  dst->set_calc_state(src.calc_state);
  dst->set_id(src.id);
  Struct2Proto_Poly_BUS(src.curve, dst->mutable_curve());
}

void Struct2Proto_EVM_VT_LANE_BUS(const EVM_VT_LANE_BUS& src, zpilot::TOS::proto::EVM_VT_LANE_BUS* dst) {
  dst->set_id(src.id);
  dst->set_team_obj_total_num(src.team_obj_total_num);
  Struct2Proto_Refline_BUS(src.traj_refline, dst->mutable_traj_refline());
}

void Struct2Proto_EVM_CIPV_TRAJ_BUS(const EVM_CIPV_TRAJ_BUS& src, zpilot::TOS::proto::EVM_CIPV_TRAJ_BUS* dst) {
  dst->set_id(src.id);
  dst->set_same_team_obj_num(src.same_team_obj_num);
  dst->set_obj_width(src.obj_width);
  dst->set_ref_obj_id(src.ref_obj_id);
  Struct2Proto_Refline_BUS(src.traj_refline, dst->mutable_traj_refline());
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::TOS::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_EVM_NUDGE_BUS(const EVM_NUDGE_BUS& src, zpilot::TOS::proto::EVM_NUDGE_BUS* dst) {
  dst->set_nudge_type(src.nudge_type);
  dst->set_ref_lane_id(src.ref_lane_id);
  dst->set_nudge_dx(src.nudge_dx);
  dst->set_nudge_offset(src.nudge_offset);
  dst->set_nudge_speed_limit(src.nudge_speed_limit);
  dst->set_reserved(src.reserved);
  dst->set_obj_id(src.obj_id);
}

void Struct2Proto_Vector_BUS(const Vector_BUS& src, zpilot::TOS::proto::Vector_BUS* dst) {
  dst->set_x(src.x);
  dst->set_y(src.y);
  dst->set_mod(src.mod);
}

void Struct2Proto_Position_BUS(const Position_BUS& src, zpilot::TOS::proto::Position_BUS* dst) {
  dst->set_x(src.x);
  dst->set_y(src.y);
  dst->set_heading_angle(src.heading_angle);
}

void Struct2Proto_Box_BUS(const Box_BUS& src, zpilot::TOS::proto::Box_BUS* dst) {
  for (const auto& struct_item : src.corner_x_vec) {
      dst->add_corner_x_vec(struct_item);
   }
  for (const auto& struct_item : src.corner_y_vec) {
      dst->add_corner_y_vec(struct_item);
   }
}

void Struct2Proto_Size_BUS(const Size_BUS& src, zpilot::TOS::proto::Size_BUS* dst) {
  dst->set_length(src.length);
  dst->set_width(src.width);
  dst->set_higth(src.higth);
}

void Struct2Proto_EVM_CIPV_BUS(const EVM_CIPV_BUS& src, zpilot::TOS::proto::EVM_CIPV_BUS* dst) {
  dst->set_meas_state(src.meas_state);
  dst->set_fus_type(src.fus_type);
  dst->set_class_type(src.class_type);
  dst->set_cut_type(src.cut_type);
  dst->set_ref_lane_id(src.ref_lane_id);
  dst->set_id(src.id);
  Struct2Proto_Box_BUS(src.box, dst->mutable_box());
  Struct2Proto_Position_BUS(src.position, dst->mutable_position());
  Struct2Proto_Position_BUS(src.position_sl, dst->mutable_position_sl());
  Struct2Proto_Size_BUS(src.size, dst->mutable_size());
  Struct2Proto_Vector_BUS(src.velocity_gnd, dst->mutable_velocity_gnd());
  Struct2Proto_Vector_BUS(src.accel_gnd, dst->mutable_accel_gnd());
  Struct2Proto_Vector_BUS(src.velocity_gnd_sl, dst->mutable_velocity_gnd_sl());
  Struct2Proto_Vector_BUS(src.accel_gnd_sl, dst->mutable_accel_gnd_sl());
}

void Struct2Proto_EVM_LANE_MAXSPD_BUS(const EVM_LANE_MAXSPD_BUS& src, zpilot::TOS::proto::EVM_LANE_MAXSPD_BUS* dst) {
  dst->set_lane_id(src.lane_id);
  dst->set_max_spd_high_assumed(src.max_spd_high_assumed);
  dst->set_max_spd_low_assumed(src.max_spd_low_assumed);
  dst->set_spd_block_dis(src.spd_block_dis);
}

void Struct2Proto_TOS_OBJs(const TOS_OBJs& src, zpilot::TOS::proto::TOS_OBJs* dst) {
  for (const auto& struct_item : src.fu_type) {
      dst->add_fu_type(struct_item);
   }
  for (const auto& struct_item : src.exist_prob) {
      dst->add_exist_prob(struct_item);
   }
  for (const auto& struct_item : src.type_prob) {
      dst->add_type_prob(struct_item);
   }
  for (const auto& struct_item : src.headingAngle) {
      dst->add_headingangle(struct_item);
   }
  for (const auto& struct_item : src.ID) {
      dst->add_id(struct_item);
   }
  for (const auto& struct_item : src.Cipv_flag) {
      dst->add_cipv_flag(struct_item);
   }
  for (const auto& struct_item : src.age) {
      dst->add_age(struct_item);
   }
  for (const auto& struct_item : src.movingSts) {
      dst->add_movingsts(struct_item);
   }
  for (const auto& struct_item : src.type) {
      dst->add_type(struct_item);
   }
  for (const auto& struct_item : src.vxAbs) {
      dst->add_vxabs(struct_item);
   }
  for (const auto& struct_item : src.vyAbs) {
      dst->add_vyabs(struct_item);
   }
  for (const auto& struct_item : src.axAbs) {
      dst->add_axabs(struct_item);
   }
  for (const auto& struct_item : src.ayAbs) {
      dst->add_ayabs(struct_item);
   }
  for (const auto& struct_item : src.Length) {
      dst->add_length(struct_item);
   }
  for (const auto& struct_item : src.Width) {
      dst->add_width(struct_item);
   }
  for (const auto& struct_item : src.Hight) {
      dst->add_hight(struct_item);
   }
  for (const auto& struct_item : src.dx) {
      dst->add_dx(struct_item);
   }
  for (const auto& struct_item : src.dy) {
      dst->add_dy(struct_item);
   }
  for (const auto& struct_item : src.yawAngle) {
      dst->add_yawangle(struct_item);
   }
  for (const auto& struct_item : src.orientation) {
      dst->add_orientation(struct_item);
   }
  for (const auto& struct_item : src.MovDir) {
      dst->add_movdir(struct_item);
   }
  for (const auto& struct_item : src.FL_dx) {
      dst->add_fl_dx(struct_item);
   }
  for (const auto& struct_item : src.FL_dy) {
      dst->add_fl_dy(struct_item);
   }
  for (const auto& struct_item : src.FR_dx) {
      dst->add_fr_dx(struct_item);
   }
  for (const auto& struct_item : src.FR_dy) {
      dst->add_fr_dy(struct_item);
   }
  for (const auto& struct_item : src.RL_dx) {
      dst->add_rl_dx(struct_item);
   }
  for (const auto& struct_item : src.RL_dy) {
      dst->add_rl_dy(struct_item);
   }
  for (const auto& struct_item : src.RR_dx) {
      dst->add_rr_dx(struct_item);
   }
  for (const auto& struct_item : src.RR_dy) {
      dst->add_rr_dy(struct_item);
   }
  for (const auto& struct_item : src.breakLmpSts) {
      dst->add_breaklmpsts(struct_item);
   }
  for (const auto& struct_item : src.camCutInFlag) {
      dst->add_camcutinflag(struct_item);
   }
  for (const auto& struct_item : src.turnLmpSts) {
      dst->add_turnlmpsts(struct_item);
   }
  for (const auto& struct_item : src.camObjLaneAssignment) {
      dst->add_camobjlaneassignment(struct_item);
   }
  for (const auto& struct_item : src.camDx) {
      dst->add_camdx(struct_item);
   }
  for (const auto& struct_item : src.camDy) {
      dst->add_camdy(struct_item);
   }
  for (const auto& struct_item : src.camCutInSpd) {
      dst->add_camcutinspd(struct_item);
   }
  for (const auto& struct_item : src.camID) {
      dst->add_camid(struct_item);
   }
  for (const auto& struct_item : src.camCutInDist) {
      dst->add_camcutindist(struct_item);
   }
  for (const auto& struct_item : src.vxRel) {
      dst->add_vxrel(struct_item);
   }
  for (const auto& struct_item : src.vyRel) {
      dst->add_vyrel(struct_item);
   }
  for (const auto& struct_item : src.axRel) {
      dst->add_axrel(struct_item);
   }
  for (const auto& struct_item : src.ayRel) {
      dst->add_ayrel(struct_item);
   }
  for (const auto& struct_item : src.offset_flag) {
      dst->add_offset_flag(struct_item);
   }
  for (const auto& struct_item : src.offset_value) {
      dst->add_offset_value(struct_item);
   }
  for (const auto& struct_item : src.OverlapRatio_LM) {
      dst->add_overlapratio_lm(struct_item);
   }
  for (const auto& struct_item : src.OverlapRatio_OTL) {
      dst->add_overlapratio_otl(struct_item);
   }
  for (const auto& struct_item : src.DistIn_Lane) {
      dst->add_distin_lane(struct_item);
   }
  for (const auto& struct_item : src.DistOut_Lane) {
      dst->add_distout_lane(struct_item);
   }
  for (const auto& struct_item : src.CutIn_Flag) {
      dst->add_cutin_flag(struct_item);
   }
  for (const auto& struct_item : src.Obj_CutIn) {
      dst->add_obj_cutin(struct_item);
   }
  for (const auto& struct_item : src.Obj_CutOut) {
      dst->add_obj_cutout(struct_item);
   }
  for (const auto& struct_item : src.PressedLaneSts) {
      dst->add_pressedlanests(struct_item);
   }
  for (const auto& struct_item : src.Dis_Lateral) {
      dst->add_dis_lateral(struct_item);
   }
  for (const auto& struct_item : src.LcDis_Lateral) {
      dst->add_lcdis_lateral(struct_item);
   }
  for (const auto& struct_item : src.SameLaneConfirms) {
      dst->add_samelaneconfirms(struct_item);
   }
}

void Struct2Proto_TOS_SecondSele_Object_BUS(const TOS_SecondSele_Object_BUS& src, zpilot::TOS::proto::TOS_SecondSele_Object_BUS* dst) {
  for (const auto& struct_item : src.movingState) {
      dst->add_movingstate(struct_item);
   }
  for (const auto& struct_item : src.orientation) {
      dst->add_orientation(struct_item);
   }
  for (const auto& struct_item : src.type) {
      dst->add_type(struct_item);
   }
  for (const auto& struct_item : src.fu_type) {
      dst->add_fu_type(struct_item);
   }
  for (const auto& struct_item : src.id) {
      dst->add_id(struct_item);
   }
  for (const auto& struct_item : src.dx) {
      dst->add_dx(struct_item);
   }
  for (const auto& struct_item : src.dy) {
      dst->add_dy(struct_item);
   }
  for (const auto& struct_item : src.vxRel) {
      dst->add_vxrel(struct_item);
   }
  for (const auto& struct_item : src.vyRel) {
      dst->add_vyrel(struct_item);
   }
  for (const auto& struct_item : src.headingAngle) {
      dst->add_headingangle(struct_item);
   }
  for (const auto& struct_item : src.length) {
      dst->add_length(struct_item);
   }
  for (const auto& struct_item : src.width) {
      dst->add_width(struct_item);
   }
  for (const auto& struct_item : src.ax) {
      dst->add_ax(struct_item);
   }
  for (const auto& struct_item : src.ay) {
      dst->add_ay(struct_item);
   }
}

void Struct2Proto_TOS_Measurement(const TOS_Measurement& src, zpilot::TOS::proto::TOS_Measurement* dst) {
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcIn_StbM_TimeStamp, dst->mutable_swcin_stbm_timestamp());
  for (const auto& struct_item : src.SwcOut_EVM_CIPV) {
      Struct2Proto_EVM_CIPV_BUS(struct_item, dst->add_swcout_evm_cipv());
   }
  Struct2Proto_EVM_CIPV_TRAJ_BUS(src.SwcOut_EVM_CIPV_TRAJ, dst->mutable_swcout_evm_cipv_traj());
  for (const auto& struct_item : src.SwcOut_EVM_LANE_MAXSPD) {
      Struct2Proto_EVM_LANE_MAXSPD_BUS(struct_item, dst->add_swcout_evm_lane_maxspd());
   }
  Struct2Proto_EVM_NUDGE_BUS(src.SwcOut_EVM_LANE_NUDGE, dst->mutable_swcout_evm_lane_nudge());
  Struct2Proto_EVM_VT_LANE_BUS(src.SwcOut_EVM_VT_LANE, dst->mutable_swcout_evm_vt_lane());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP0, dst->mutable_swcout_tos_accp0());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP1, dst->mutable_swcout_tos_accp1());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP2, dst->mutable_swcout_tos_accp2());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP3, dst->mutable_swcout_tos_accp3());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP4, dst->mutable_swcout_tos_accp4());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP5, dst->mutable_swcout_tos_accp5());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP6, dst->mutable_swcout_tos_accp6());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP7, dst->mutable_swcout_tos_accp7());
  Struct2Proto_TOS_ACC_BUS(src.SwcOut_TOS_ACCP8, dst->mutable_swcout_tos_accp8());
  for (const auto& struct_item : src.SwcOut_TOS_AEB) {
      Struct2Proto_TOS_AEB_BUS(struct_item, dst->add_swcout_tos_aeb());
   }
  Struct2Proto_TOS_HWA_BUS(src.SwcOut_TOS_HWA, dst->mutable_swcout_tos_hwa());
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_TOS_Herbeat_Info, dst->mutable_swcout_tos_herbeat_info());
  dst->set_swcout_tos_lm_fuscase(src.SwcOut_TOS_LM_FusCase);
  Struct2Proto_TOS_LM_TRAJINFO_BUS(src.SwcOut_TOS_LM_LL, dst->mutable_swcout_tos_lm_ll());
  Struct2Proto_TOS_LM_TRAJINFO_BUS(src.SwcOut_TOS_LM_LR, dst->mutable_swcout_tos_lm_lr());
  Struct2Proto_TOS_LM_TRAJINFO_BUS(src.SwcOut_TOS_LM_RL, dst->mutable_swcout_tos_lm_rl());
  Struct2Proto_TOS_LM_TRAJINFO_BUS(src.SwcOut_TOS_LM_RR, dst->mutable_swcout_tos_lm_rr());
  Struct2Proto_Lc_Sts(src.SwcOut_TOS_LcSts, dst->mutable_swcout_tos_lcsts());
  for (const auto& struct_item : src.TOS_DOPSelectDiffRef) {
      dst->add_tos_dopselectdiffref(struct_item);
   }
  dst->set_tos_dopselectreason(src.TOS_DOPSelectReason);
  Struct2Proto_LINE_BUS(src.TOS_HLane, dst->mutable_tos_hlane());
  Struct2Proto_LINE_BUS(src.TOS_LL, dst->mutable_tos_ll());
  Struct2Proto_LINE_BUS(src.TOS_LLane, dst->mutable_tos_llane());
  Struct2Proto_LINE_BUS(src.TOS_LR, dst->mutable_tos_lr());
  Struct2Proto_TOS_OBJs(src.TOS_OFM_OBJs, dst->mutable_tos_ofm_objs());
  for (const auto& struct_item : src.TOS_OPParalNum) {
      dst->add_tos_opparalnum(struct_item);
   }
  dst->set_tos_opselectindex(src.TOS_OPSelectIndex);
  Struct2Proto_LINE_BUS(src.TOS_RL, dst->mutable_tos_rl());
  Struct2Proto_LINE_BUS(src.TOS_RLane, dst->mutable_tos_rlane());
  Struct2Proto_LINE_BUS(src.TOS_RR, dst->mutable_tos_rr());
  dst->set_tos_updatecnt(src.TOS_UpdateCnt);
  dst->set_tos_version(src.TOS_Version);
  dst->set_tos_reserve01(src.TOS_reserve01);
  dst->set_tos_reserve02(src.TOS_reserve02);
  dst->set_tos_reserve03(src.TOS_reserve03);
  dst->set_tos_reserve04(src.TOS_reserve04);
  dst->set_tos_reserve05(src.TOS_reserve05);
  dst->set_tos_reserve06(src.TOS_reserve06);
  dst->set_tos_reserve07(src.TOS_reserve07);
  dst->set_tos_reserve08(src.TOS_reserve08);
  dst->set_tos_reserve09(src.TOS_reserve09);
  dst->set_tos_reserve10(src.TOS_reserve10);
  dst->set_timestamp(src.timestamp);
  Struct2Proto_TOS_SecondSele_Object_BUS(src.SwcOut_TOS_SecondSele_Object, dst->mutable_swcout_tos_secondsele_object());
}

void Struct2Proto_J3_RM_ELEM_BUS(const J3_RM_ELEM_BUS& src, zpilot::j3_rm::proto::J3_RM_ELEM_BUS* dst) {
  dst->set_rm_confidence(src.RM_Confidence);
  dst->set_rm_id(src.RM_ID);
  dst->set_rm_mark_type(src.RM_Mark_Type);
  dst->set_rm_relevancy(src.RM_Relevancy);
  dst->set_rm_position_x(src.RM_Position_X);
  dst->set_rm_position_y(src.RM_Position_Y);
  dst->set_rm_internal_id(src.RM_Internal_ID);
}

void Struct2Proto_J3_RM_HDR_BUS(const J3_RM_HDR_BUS& src, zpilot::j3_rm::proto::J3_RM_HDR_BUS* dst) {
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_rmobjectsnumber(src.RMObjectsNumber);
  dst->set_rollingcounter_rmtfc(src.RollingCounter_RMTFC);
  dst->set_crcchecksum_rmtfc(src.CRCChecksum_RMTFC);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_rm::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_RM_BUS(const J3_RM_BUS& src, zpilot::j3_rm::proto::J3_RM_BUS* dst) {
  Struct2Proto_J3_RM_HDR_BUS(src.J3_RM_HDR, dst->mutable_j3_rm_hdr());
  Struct2Proto_J3_SYNC_BUS(src.J3_RM_SYNC, dst->mutable_j3_rm_sync());
  for (const auto& struct_item : src.J3_RM_ELEM) {
      Struct2Proto_J3_RM_ELEM_BUS(struct_item, dst->add_j3_rm_elem());
   }
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::ICAS::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_ICAS_STATE_BUS(const ICAS_STATE_BUS& src, zpilot::ICAS::proto::ICAS_STATE_BUS* dst) {
  dst->set_acc_sts(src.acc_sts);
  dst->set_lcc_sts(src.lcc_sts);
  dst->set_nudge_sts(src.nudge_sts);
  dst->set_alc_sts(src.alc_sts);
  dst->set_noa_sts(src.noa_sts);
  dst->set_lc_req_sync_id(src.lc_req_sync_id);
  dst->set_acc_manual_act_faile_reason(src.acc_manual_act_faile_reason);
  dst->set_acc_exit_reason(src.acc_exit_reason);
  dst->set_lcc_manual_act_faile_reason(src.lcc_manual_act_faile_reason);
  dst->set_lcc_auto_act_faile_reason(src.lcc_auto_act_faile_reason);
  dst->set_lcc_exit_to_idle_reason(src.lcc_exit_to_idle_reason);
  dst->set_lcc_exit_to_wait_reason(src.lcc_exit_to_wait_reason);
  dst->set_lcc_exit_to_mrc_reason(src.lcc_exit_to_mrc_reason);
  dst->set_lcc_mrc_exit_reason(src.lcc_mrc_exit_reason);
  dst->set_noa_auto_act_faile_reason(src.noa_auto_act_faile_reason);
  dst->set_noa_exit_reason(src.noa_exit_reason);
}

void Struct2Proto_ICAS_HMI_BUS(const ICAS_HMI_BUS& src, zpilot::ICAS::proto::ICAS_HMI_BUS* dst) {
  dst->set_ecallreq(src.EcallReq);
  dst->set_parkshiftreq(src.ParkShiftReq);
  dst->set_acc_moddisp(src.ACC_ModDisp);
  dst->set_lcc_modedisp(src.LCC_ModeDisp);
  dst->set_alc_modedisp(src.ALC_ModeDisp);
  dst->set_noa_modedisp(src.NOA_ModeDisp);
  dst->set_dai_modedisp(src.DAI_ModeDisp);
  dst->set_nudge_modedisp(src.Nudge_ModeDisp);
  dst->set_ihbc_modedisp(src.IHBC_ModeDisp);
  dst->set_highlowbeamreq(src.HighLowBeamReq);
  dst->set_hazactv(src.HazActv);
  dst->set_turnlampreq(src.TurnLampReq);
  dst->set_driveoffdisp(src.DriveOffDisp);
  dst->set_handsoffwarninglevel(src.HandsOffWarningLevel);
  dst->set_driverinloopmonitor(src.DriverInloopMonitor);
  dst->set_warninglevel(src.WarningLevel);
  for (const auto& struct_item : src.InfoDispHMI) {
      dst->add_infodisphmi(struct_item);
   }
}

void Struct2Proto_CSC_CTRL_BUS(const CSC_CTRL_BUS& src, zpilot::ICAS::proto::CSC_CTRL_BUS* dst) {
  dst->set_vsetbelowmin(src.VsetBelowMin);
  dst->set_cruisespdctrllevel(src.CruiseSpdCtrlLevel);
  dst->set_timegaplevel(src.TimeGapLevel);
  dst->set_cruisespdkmh(src.CruiseSpdKmh);
  dst->set_isl_apspdlimspl(src.ISL_APSpdLimSPL);
  dst->set_isl_apspdlimdist(src.ISL_APSpdLimDist);
}

void Struct2Proto_TSR_HMI_BUS(const TSR_HMI_BUS& src, zpilot::ICAS::proto::TSR_HMI_BUS* dst) {
  dst->set_tsrspdlimwarn(src.TSRSpdLimWarn);
  dst->set_tsrconspdlimwarn(src.TSRConSpdLimWarn);
  dst->set_tsr_snvty(src.TSR_Snvty);
  dst->set_tsrsts(src.TSRSts);
  dst->set_tsrspdlimunit(src.TSRSpdLimUnit);
  dst->set_tsrspdlimsts(src.TSRSpdLimSts);
  dst->set_tsrspdlim(src.TSRSpdLim);
  dst->set_tsrspdlimcfdc(src.TSRSpdLimCfdc);
  dst->set_tsrconspdlim(src.TSRConSpdLim);
  dst->set_tsr_giveway(src.TSR_GiveWay);
  dst->set_tsr_longtimedisplay(src.TSR_LongTimeDisplay);
  dst->set_tsr_forbidden(src.TSR_Forbidden);
  dst->set_tsrtrfcsignvalcfdc(src.TSRTrfcSignValCfdc);
}

void Struct2Proto_CSC_HMI_BUS(const CSC_HMI_BUS& src, zpilot::ICAS::proto::CSC_HMI_BUS* dst) {
  dst->set_cruisespdvaluehmi(src.CruiseSpdValueHMI);
  dst->set_timegaplevelhmi(src.TimeGapLevelHMI);
  dst->set_infodisphmi(src.InfoDispHMI);
  dst->set_isl_sts(src.ISL_Sts);
  dst->set_isl_setspdadjreq(src.ISL_SetSpdAdjReq);
  dst->set_isl_setspdadjval(src.ISL_SetSpdAdjVal);
  dst->set_isl_noa_spl_kph(src.ISL_NOA_SPL_kph);
  dst->set_isl_noa_spl_distance2split(src.ISL_NOA_SPL_Distance2Split);
  dst->set_isl_iacclolim_kph(src.ISL_iAccLoLim_kph);
  dst->set_isl_iacchilim_kph(src.ISL_iAccHiLim_kph);
}

void Struct2Proto_TSR_INIT_BUS(const TSR_INIT_BUS& src, zpilot::ICAS::proto::TSR_INIT_BUS* dst) {
  dst->set_spl_nosupp_value_init(src.SPL_noSupp_Value_Init);
  dst->set_spl_whsupp_value_init(src.SPL_whSupp_Value_Init);
  dst->set_ts_signname_value_init(src.TS_SignName_Value_Init);
  dst->set_spl_suppname_value_init(src.SPL_SuppName_Value_Init);
  dst->set_spl_nosupp_dist_init(src.SPL_noSupp_Dist_Init);
  dst->set_spl_whsupp_dist_init(src.SPL_whSupp_Dist_Init);
  dst->set_ts_signname_dist_init(src.TS_SignName_Dist_Init);
}

void Struct2Proto_ICAS_Measurement(const ICAS_Measurement& src, zpilot::ICAS::proto::ICAS_Measurement* dst) {
  dst->set_csc_isl_infodisphmi(src.CSC_ISL_InfoDispHMI);
  dst->set_csm_autoadjsetspdval(src.CSM_AutoAdjSetSpdVal);
  dst->set_csm_isl_noa_distance2splitafterlim(src.CSM_ISL_NOA_Distance2SplitAfterLim);
  dst->set_csm_isl_noa_spl_offrampstart(src.CSM_ISL_NOA_SPL_OFFRampStart);
  dst->set_csm_isl_sts_st(src.CSM_ISL_Sts_st);
  dst->set_csm_offrampdisreq(src.CSM_OffRampDisReq);
  dst->set_csm_offrampspdreq(src.CSM_OffRampSpdReq);
  dst->set_csm_tsrspdlimsts_st(src.CSM_TSRSpdLimSts_st);
  dst->set_csm_tsrspdlimwarn_b(src.CSM_TSRSpdLimWarn_b);
  dst->set_csm_tsrspdlim_kph(src.CSM_TSRSpdLim_kph);
  dst->set_csm_tsr_j3splval(src.CSM_TSR_J3SPLVAL);
  dst->set_csm_tsr_spl_memry(src.CSM_TSR_SPL_Memry);
  dst->set_csm_timegapinit(src.CSM_TimeGapInit);
  dst->set_csm_timegaplevel(src.CSM_TimeGapLevel);
  dst->set_csm_version(src.CSM_Version);
  dst->set_icas_accactcondf(src.ICAS_ACCActCondF);
  dst->set_icas_accactiveconenable(src.ICAS_ACCActiveConEnable);
  dst->set_icas_accfastexit(src.ICAS_ACCFastExit);
  dst->set_icas_accfastexitcons_hoodopen(src.ICAS_ACCFastExitCons_HoodOpen);
  dst->set_icas_accfastexitcons_lrdooropen(src.ICAS_ACCFastExitCons_LRDoorOpen);
  dst->set_icas_accfastexitcons_passengerdooropen(src.ICAS_ACCFastExitCons_PassengerDoorOpen);
  dst->set_icas_accfastexitcons_rrdooropen(src.ICAS_ACCFastExitCons_RRDoorOpen);
  dst->set_icas_accslowexit(src.ICAS_ACCSlowExit);
  dst->set_icas_acc_accsts(src.ICAS_ACC_ACCSts);
  dst->set_icas_acc_avpfunstatus(src.ICAS_ACC_AVPFunStatus);
  dst->set_icas_acc_bomexit(src.ICAS_ACC_BOMExit);
  dst->set_icas_acc_drvoffreq(src.ICAS_ACC_DrvOFFReq);
  dst->set_icas_acc_hazactv(src.ICAS_ACC_HazActv);
  dst->set_icas_acc_modedisp(src.ICAS_ACC_ModeDisp);
  dst->set_icas_acc_standactivetime(src.ICAS_ACC_StandActiveTime);
  dst->set_icas_acc_uss_accp0rangeen(src.ICAS_ACC_USS_ACCP0rangeEN);
  dst->set_icas_acc_uss_drvroffconen(src.ICAS_ACC_USS_DrvroffConEn);
  dst->set_icas_acc_uss_drvroffdisp(src.ICAS_ACC_USS_Drvroffdisp);
  dst->set_icas_acc_uss_tosp0typechange(src.ICAS_ACC_USS_TOSP0TypeChange);
  dst->set_icas_acc_uss_ussobjexist(src.ICAS_ACC_USS_USSObjExist);
  dst->set_icas_acc_uss_rangep0detdec(src.ICAS_ACC_USS_rangeP0DetDec);
  dst->set_icas_aeb_hazactv(src.ICAS_AEB_HazActv);
  dst->set_icas_hwafastexitcond_accexit(src.ICAS_HWAFastExitCond_ACCExit);
  dst->set_icas_hwaslowexitconditions_b(src.ICAS_HWASlowExitConditions_b);
  dst->set_icas_hwaslowexitcons_espactive400ms(src.ICAS_HWASlowExitCons_EspActive400ms);
  dst->set_icas_hwatja_hwawarninglevel(src.ICAS_HWATJA_HWAWarningLevel);
  dst->set_icas_hwatja_mrc2safestopcon_b(src.ICAS_HWATJA_MRC2SafeStopCon_b);
  dst->set_icas_longhmi_number(src.ICAS_LongHMI_Number);
  dst->set_icas_longhmi_version(src.ICAS_LongHMI_VERSION);
  dst->set_icas_tjahandsoffwarninglevel(src.ICAS_TJAHandsOffWarningLevel);
  dst->set_icas_tjalck_con_tjaactive_latcondition_b(src.ICAS_TJALCK_Con_TJAActive_LatCondition_b);
  dst->set_icas_tjalck_con_tjaexit_latcondition_b(src.ICAS_TJALCK_Con_TJAExit_LatCondition_b);
  dst->set_icas_tjalck_predis(src.ICAS_TJALCK_preDis);
  dst->set_icas_tja_modedisp(src.ICAS_TJA_ModeDisp);
  dst->set_icas_tja_number(src.ICAS_TJA_Number);
  dst->set_icas_tja_version(src.ICAS_TJA_VERSION);
  dst->set_icas_version(src.ICAS_Version);
  dst->set_icas_longhmi_cruisetextdisp(src.ICAS_longHMI_CRUISETextDisp);
  dst->set_icas_longhmi_hazsts(src.ICAS_longHMI_HazSts);
  dst->set_icas_longhmi_hazswsts(src.ICAS_longHMI_HazSwSts);
  dst->set_icas_longhmi_truckcount(src.ICAS_longHMI_TruckCount);
  dst->set_icas_reserve01(src.ICAS_reserve01);
  dst->set_icas_reserve02(src.ICAS_reserve02);
  dst->set_icas_reserve03(src.ICAS_reserve03);
  dst->set_icas_reserve04(src.ICAS_reserve04);
  dst->set_icas_reserve05(src.ICAS_reserve05);
  dst->set_icas_reserve06(src.ICAS_reserve06);
  dst->set_icas_reserve07(src.ICAS_reserve07);
  dst->set_icas_reserve08(src.ICAS_reserve08);
  dst->set_icas_reserve09(src.ICAS_reserve09);
  dst->set_icas_reserve10(src.ICAS_reserve10);
  dst->set_map_tsr_spdlim_in(src.MAP_TSR_SpdLim_in);
  dst->set_ihc_version(src.IHC_Version);
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_ICAS_Herbeat_Info, dst->mutable_swcout_icas_herbeat_info());
  dst->set_swcout_icas_adas_request(src.SwcOut_ICAS_ADAS_Request);
  dst->set_swcout_icas_nvm_set_accstsinit(src.SwcOut_ICAS_NvM_Set_ACCStsInit);
  dst->set_swcout_nvm_set_timegapinit(src.SwcOut_NvM_Set_TimeGapInit);
  dst->set_swcout_icas_nvm_set_icasstsinit(src.Swcout_ICAS_NvM_Set_ICASStsInit);
  Struct2Proto_CSC_HMI_BUS(src.SwcOut_CSM_CSC_HMI, dst->mutable_swcout_csm_csc_hmi());
  Struct2Proto_CSC_CTRL_BUS(src.SwcOut_CSM_CTRL, dst->mutable_swcout_csm_ctrl());
  Struct2Proto_TSR_HMI_BUS(src.SwcOut_CSM_TSR_HMI, dst->mutable_swcout_csm_tsr_hmi());
  Struct2Proto_ICAS_HMI_BUS(src.SwcOut_ICAS_HMI, dst->mutable_swcout_icas_hmi());
  Struct2Proto_ICAS_STATE_BUS(src.SwcOut_ICAS_STATE, dst->mutable_swcout_icas_state());
  Struct2Proto_TSR_INIT_BUS(src.SwcOut_NvM_Set_TSRInit, dst->mutable_swcout_nvm_set_tsrinit());
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::VAL::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_VAL_DRIVER_SWITCH_BUS(const VAL_DRIVER_SWITCH_BUS& src, zpilot::VAL::proto::VAL_DRIVER_SWITCH_BUS* dst) {
  dst->set_nohonoff(src.NOHOnOff);
  dst->set_nohactreq(src.NOHActReq);
  dst->set_ldwonoff(src.LDWOnOff);
  dst->set_lkaonoff(src.LKAOnOff);
  dst->set_elkonoff(src.ELKOnOff);
  dst->set_essonoff(src.ESSOnOff);
  dst->set_aesonoff(src.AESOnOff);
  dst->set_lckieonoff(src.LCKIEOnOff);
  dst->set_islonoff(src.ISLOnOff);
  dst->set_intellgntcurveonoff(src.IntellgntCurveOnOff);
  dst->set_fcwonoff(src.FCWOnOff);
  dst->set_aebonoff(src.AEBOnOff);
  dst->set_daionoff(src.DAIOnOff);
  dst->set_speedlmtnumberabs(src.SpeedLmtNumberAbs);
  dst->set_speedlmtnumberperct(src.SpeedLmtNumberPerct);
  dst->set_speedlmtsnvtymod(src.SpeedLmtSnvtyMod);
  dst->set_ihconoff(src.IHCOnOff);
  dst->set_icaonoff(src.ICAOnOff);
  dst->set_slaonoff(src.SLAOnOff);
  dst->set_slawarnmod(src.SLAWarnMod);
  dst->set_lassnvtyset(src.LASSnvtySet);
  dst->set_laswarnformswtreq(src.LASWarnFormSwtReq);
  dst->set_tsronoff(src.TSROnOff);
  dst->set_tlionoff(src.TLIOnOff);
  dst->set_alcset(src.ALCSet);
  dst->set_dclcset(src.DCLCSet);
  dst->set_alcsnvtyset(src.ALCSnvtySet);
  dst->set_fcwsnvty(src.FCWSnvty);
  dst->set_voiceremindtype(src.VoiceRemindType);
  dst->set_tjaicaexittextinfoonoff(src.TJAICAExitTextInfoONOFF);
  dst->set_speedlimitonoff(src.SpeedLimitOnOff);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_VAL_DRIVER_DRIVE_BUS(const VAL_DRIVER_DRIVE_BUS& src, zpilot::VAL::proto::VAL_DRIVER_DRIVE_BUS* dst) {
  dst->set_accpedaloverride(src.AccPedalOverride);
  dst->set_actpulse(src.ActPulse);
  dst->set_cancelpulse(src.CancelPulse);
  dst->set_incsetspdpulse(src.IncSetSpdPulse);
  dst->set_decsetspdpulse(src.DecSetSpdPulse);
  dst->set_inctimegappulse(src.IncTimeGapPulse);
  dst->set_dectimegappulse(src.DecTimeGapPulse);
  dst->set_hazardlmpswtsts(src.HazardLmpSwtSts);
  dst->set_drvbrakepedalsts(src.DrvBrakePedalSts);
  dst->set_epbswtsts(src.EPBSwtSts);
  dst->set_lturnlmpswtsts(src.LTurnLmpSwtSts);
  dst->set_rturnlmpswtsts(src.RTurnLmpSwtSts);
  dst->set_highbeamswtsts(src.HighBeamSwtSts);
  dst->set_overvehbeamswtsts(src.OverVehBeamSwtSts);
  dst->set_autolightsw(src.AutoLightSW);
  dst->set_incsetspdstep(src.IncSetSpdStep);
  dst->set_decsetspdstep(src.DecSetSpdStep);
  dst->set_drvconfirmlc(src.DrvConfirmLC);
  dst->set_drvvoicelcreq(src.DrvVoiceLCReq);
  dst->set_drvvoicespdadjreq(src.DrvVoiceSpdAdjReq);
  dst->set_drvvoicespdadjreqvalue(src.DrvVoiceSpdAdjReqValue);
  dst->set_drvbrakeaccel(src.DrvBrakeAccel);
  dst->set_accpedaltouchposition(src.AccPedalTouchPosition);
  dst->set_drvsteertrqval(src.DrvSteerTrqVal);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_VAL_DRIVER_STATE_BUS(const VAL_DRIVER_STATE_BUS& src, zpilot::VAL::proto::VAL_DRIVER_STATE_BUS* dst) {
  dst->set_handsoff(src.HandsOff);
  dst->set_driversts(src.DriverSts);
  dst->set_dmsauthsts(src.DMSAuthSts);
  dst->set_gpsauthsts(src.GPSAuthSts);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_VAL_VEHICLE_STATE_BUS(const VAL_VEHICLE_STATE_BUS& src, zpilot::VAL::proto::VAL_VEHICLE_STATE_BUS* dst) {
  dst->set_vehstandstill(src.VehStandstill);
  dst->set_engineon(src.EngineOn);
  dst->set_fashiftinprogress(src.FAShiftInProgress);
  dst->set_rashiftinprogress(src.RAShiftInProgress);
  dst->set_nobrakeforce(src.NoBrakeForce);
  dst->set_vlc_internaltargetaccelerationvalid(src.VLC_InternalTargetAccelerationValid);
  dst->set_blindtemp(src.BlindTemp);
  dst->set_wheelpulsecountervalid(src.WheelPulseCounterValid);
  dst->set_currentgear(src.CurrentGear);
  dst->set_targetgear(src.TargetGear);
  dst->set_gearsts(src.GearSts);
  dst->set_syspowermod(src.SysPowerMod);
  dst->set_ipvehspdunit(src.IPVehSpdUnit);
  dst->set_ipvehspddispkph(src.IPVehSpdDispKph);
  dst->set_ipvehspddispmph(src.IPVehSpdDispMph);
  dst->set_fourwhlsbrktrq(src.FourWhlsBrkTrq);
  dst->set_maxengtrqnorm(src.MaxEngTrqNorm);
  dst->set_vehspdkph(src.VehSpdKph);
  dst->set_ipvehspddispkphfloat(src.IPVehSpdDispKphFloat);
  dst->set_steerwheelangle(src.SteerWheelAngle);
  dst->set_steerwheelspd(src.SteerWheelSpd);
  dst->set_mastercylbrkpress(src.MasterCylBrkPress);
  dst->set_wheeltrqnm(src.WheelTrqNm);
  dst->set_wheeltrqminnm(src.WheelTrqMinNm);
  dst->set_vcutrqnm(src.VCUTrqNm);
  dst->set_engtrqnm(src.EngTrqNm);
  dst->set_engtrqminnm(src.EngTrqMinNm);
  dst->set_lkactrdlvdvalue(src.LKACtrDlvdValue);
  dst->set_netengtrq(src.NetEngTrq);
  dst->set_engtrqminact(src.EngTrqMinAct);
  dst->set_engspd(src.EngSpd);
  dst->set_flwheelspdmps(src.FLWheelSpdMps);
  dst->set_frwheelspdmps(src.FRWheelSpdMps);
  dst->set_rlwheelspdmps(src.RLWheelSpdMps);
  dst->set_rrwheelspdmps(src.RRWheelSpdMps);
  dst->set_sensorvehyawrateradps(src.SensorVehYawRateRadps);
  dst->set_sensorvehlonaccelmps2(src.SensorVehLonAccelMps2);
  dst->set_sensorvehlataccelmps2(src.SensorVehLatAccelMps2);
  dst->set_vlc_internaltargetacceleration(src.VLC_InternalTargetAcceleration);
  dst->set_totalodometer_km(src.TotalOdometer_km);
  dst->set_flwheelpulsecounter(src.FLWheelPulseCounter);
  dst->set_frwheelpulsecounter(src.FRWheelPulseCounter);
  dst->set_rlwheelpulsecounter(src.RLWheelPulseCounter);
  dst->set_rrwheelpulsecounter(src.RRWheelPulseCounter);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_VAL_VEHICLE_FUNC_BUS(const VAL_VEHICLE_FUNC_BUS& src, zpilot::VAL::proto::VAL_VEHICLE_FUNC_BUS* dst) {
  dst->set_cddactv(src.CDDActv);
  dst->set_fctbact(src.FCTBAct);
  dst->set_fctaact(src.FCTAAct);
  dst->set_parkact(src.ParkAct);
  dst->set_limitact(src.LIMITAct);
  dst->set_espfuncoffsts(src.ESPFuncOffSts);
  dst->set_espfuncactive(src.ESPFuncActive);
  dst->set_hdcctrl(src.HDCCtrl);
  dst->set_avhsts(src.AVHSts);
  dst->set_epbsts(src.EPBSts);
  dst->set_drvingmod(src.DrvingMod);
  dst->set_vehpowersysctrlerresp(src.VehPowerSysCtrlerResp);
  dst->set_vehbrakesysctrlerresp(src.VehBrakeSysCtrlerResp);
  dst->set_vehsteersysctrlerresp(src.VehSteerSysCtrlerResp);
  dst->set_awbavl(src.AWBAvl);
  dst->set_hbaavl(src.HBAAvl);
  dst->set_abpavl(src.ABPAvl);
  dst->set_hmasw(src.HMASW);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_VAL_VEHICLE_PARTS_BUS(const VAL_VEHICLE_PARTS_BUS& src, zpilot::VAL::proto::VAL_VEHICLE_PARTS_BUS* dst) {
  dst->set_drvsbr(src.DrvSBR);
  dst->set_passsbr(src.PassSBR);
  dst->set_brkdskovrheatd(src.BrkDskOvrheatd);
  dst->set_drvdoorsts(src.DrvDoorSts);
  dst->set_passengerdoorsts(src.PassengerDoorSts);
  dst->set_ffoglmpsts(src.FFogLmpSts);
  dst->set_rfoglmpsts(src.RFogLmpSts);
  dst->set_trailersts(src.TrailerSts);
  dst->set_rrdoorsts(src.RRDoorSts);
  dst->set_lrdoorsts(src.LRDoorSts);
  dst->set_hoodsts(src.HoodSts);
  dst->set_trunksts(src.TrunkSts);
  dst->set_airbagsts(src.AirBagSts);
  dst->set_crashsts(src.CrashSts);
  dst->set_lturnlmpsts(src.LTurnLmpSts);
  dst->set_rturnlmpsts(src.RTurnLmpSts);
  dst->set_highbeamsts(src.HighBeamSts);
  dst->set_lowbeamsts(src.LowBeamSts);
  dst->set_hazardlmpsts(src.HazardLmpSts);
  dst->set_fltirepressurests(src.FLTirePressureSts);
  dst->set_frtirepressurests(src.FRTirePressureSts);
  dst->set_rltirepressurests(src.RLTirePressureSts);
  dst->set_rrtirepressurests(src.RRTirePressureSts);
  dst->set_fwipersts(src.FWiperSts);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_VAL_ENV_BUS(const VAL_ENV_BUS& src, zpilot::VAL::proto::VAL_ENV_BUS* dst) {
  dst->set_daytime(src.DayTime);
  dst->set_weather(src.Weather);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_VAL_CONFIG_BUS(const VAL_CONFIG_BUS& src, zpilot::VAL::proto::VAL_CONFIG_BUS* dst) {
  dst->set_lkactrltype(src.LKACtrlType);
  dst->set_powertype(src.PowerType);
  dst->set_acceleratetype(src.AccelerateType);
  dst->set_timestampms(src.TimeStampMs);
}

void Struct2Proto_TSR_INIT_BUS(const TSR_INIT_BUS& src, zpilot::VAL::proto::TSR_INIT_BUS* dst) {
  dst->set_spl_nosupp_value_init(src.SPL_noSupp_Value_Init);
  dst->set_spl_whsupp_value_init(src.SPL_whSupp_Value_Init);
  dst->set_ts_signname_value_init(src.TS_SignName_Value_Init);
  dst->set_spl_suppname_value_init(src.SPL_SuppName_Value_Init);
  dst->set_spl_nosupp_dist_init(src.SPL_noSupp_Dist_Init);
  dst->set_spl_whsupp_dist_init(src.SPL_whSupp_Dist_Init);
  dst->set_ts_signname_dist_init(src.TS_SignName_Dist_Init);
}

void Struct2Proto_SomeIP_DynamicObjectInfo_BUS(const SomeIP_DynamicObjectInfo_BUS& src, zpilot::VAL::proto::SomeIP_DynamicObjectInfo_BUS* dst) {
  dst->set_objectid(src.ObjectID);
  dst->set_objecttype(src.objectType);
  dst->set_movingstatus(src.movingStatus);
  dst->set_lightstatus(src.lightStatus);
  dst->set_objectposex(src.objectPoseX);
  dst->set_objectposey(src.objectPoseY);
  dst->set_objectyaw(src.objectYaw);
  dst->set_objectpitch(src.objectPitch);
  dst->set_objectroll(src.objectRoll);
  dst->set_objectlength(src.objectLength);
  dst->set_objecwidth(src.objecWidth);
  dst->set_objectheight(src.objectHeight);
  dst->set_objectcolor(src.objectColor);
}

void Struct2Proto_SomeIP_DynamicObjectList_BUS(const SomeIP_DynamicObjectList_BUS& src, zpilot::VAL::proto::SomeIP_DynamicObjectList_BUS* dst) {
  dst->set_timestamp(src.timestamp);
  dst->set_objectcnt(src.ObjectCnt);
  for (const auto& struct_item : src.ObjectInfoList) {
      Struct2Proto_SomeIP_DynamicObjectInfo_BUS(struct_item, dst->add_objectinfolist());
   }
}

void Struct2Proto_SomeIP_LanelineInfo_BUS(const SomeIP_LanelineInfo_BUS& src, zpilot::VAL::proto::SomeIP_LanelineInfo_BUS* dst) {
  dst->set_postionparameterc0(src.PostionParameterC0);
  dst->set_headingparmeterc1(src.HeadingParmeterC1);
  dst->set_curvatureparatemerc2(src.CurvatureParatemerC2);
  dst->set_curvaturerateparatemerc3(src.CurvatureRateParatemerC3);
  dst->set_type(src.Type);
  dst->set_color(src.Color);
  dst->set_closepointx(src.ClosePointX);
  dst->set_farpointx(src.FarPointX);
  dst->set_laneposition(src.LanePosition);
}

void Struct2Proto_SomeIP_LaneLineList_BUS(const SomeIP_LaneLineList_BUS& src, zpilot::VAL::proto::SomeIP_LaneLineList_BUS* dst) {
  dst->set_timestamp(src.timestamp);
  dst->set_lanelincnt(src.LanelinCnt);
  for (const auto& struct_item : src.LanelineInfo) {
      Struct2Proto_SomeIP_LanelineInfo_BUS(struct_item, dst->add_lanelineinfo());
   }
}

void Struct2Proto_SomeIP_Othersymbol_BUS(const SomeIP_Othersymbol_BUS& src, zpilot::VAL::proto::SomeIP_Othersymbol_BUS* dst) {
  dst->set_timestamp(src.timestamp);
  dst->set_lanechangepoint(src.LaneChangePoint);
  dst->set_egovehiclestate(src.EgoVehicleState);
  dst->set_isstoparea(src.IsStoparea);
  dst->set_stopareax(src.StopareaX);
  dst->set_stoparealefty(src.StoparealeftY);
  dst->set_stoparearighty(src.StoparearightY);
}

void Struct2Proto_SomeIP_PointInfoList_BUS(const SomeIP_PointInfoList_BUS& src, zpilot::VAL::proto::SomeIP_PointInfoList_BUS* dst) {
  dst->set_coordinate_x(src.Coordinate_X);
  dst->set_coordinate_y(src.Coordinate_Y);
}

void Struct2Proto_SomeIP_PlanningPath_BUS(const SomeIP_PlanningPath_BUS& src, zpilot::VAL::proto::SomeIP_PlanningPath_BUS* dst) {
  dst->set_timestamp(src.timestamp);
  dst->set_pointcnt(src.PointCnt);
  for (const auto& struct_item : src.PointInfoList) {
      Struct2Proto_SomeIP_PointInfoList_BUS(struct_item, dst->add_pointinfolist());
   }
}

void Struct2Proto_SomeIP_StaticObjectInfo_BUS(const SomeIP_StaticObjectInfo_BUS& src, zpilot::VAL::proto::SomeIP_StaticObjectInfo_BUS* dst) {
  dst->set_objectid(src.ObjectID);
  dst->set_objecttype(src.objectType);
  dst->set_objectposex(src.objectPoseX);
  dst->set_objectposey(src.objectPoseY);
  dst->set_objectyaw(src.objectYaw);
  dst->set_objectlength(src.objectLength);
  dst->set_objecwidth(src.objecWidth);
  dst->set_objectheight(src.objectHeight);
}

void Struct2Proto_SomeIP_StaticObjectList_BUS(const SomeIP_StaticObjectList_BUS& src, zpilot::VAL::proto::SomeIP_StaticObjectList_BUS* dst) {
  dst->set_timestamp(src.timestamp);
  dst->set_objectcnt(src.ObjectCnt);
  for (const auto& struct_item : src.ObjectInfoList) {
      Struct2Proto_SomeIP_StaticObjectInfo_BUS(struct_item, dst->add_objectinfolist());
   }
}

void Struct2Proto_SomeIP_ADASDisplayExtend_BUS(const SomeIP_ADASDisplayExtend_BUS& src, zpilot::VAL::proto::SomeIP_ADASDisplayExtend_BUS* dst) {
  Struct2Proto_SomeIP_DynamicObjectList_BUS(src.DynamicObjectList_ICM, dst->mutable_dynamicobjectlist_icm());
  Struct2Proto_SomeIP_StaticObjectList_BUS(src.StaticObjectList_ICM, dst->mutable_staticobjectlist_icm());
  Struct2Proto_SomeIP_LaneLineList_BUS(src.LaneLineList_ICM, dst->mutable_lanelinelist_icm());
  Struct2Proto_SomeIP_PlanningPath_BUS(src.PlanningPath_ICM, dst->mutable_planningpath_icm());
  Struct2Proto_SomeIP_Othersymbol_BUS(src.Othersymbol_ICM, dst->mutable_othersymbol_icm());
}

void Struct2Proto_SomeIP_ParkingGenaralInfo_BUS(const SomeIP_ParkingGenaralInfo_BUS& src, zpilot::VAL::proto::SomeIP_ParkingGenaralInfo_BUS* dst) {
  dst->set_parkingvoiceremind(src.ParkingVoiceRemind);
}

void Struct2Proto_SomeIP_FuncState_HD_BUS(const SomeIP_FuncState_HD_BUS& src, zpilot::VAL::proto::SomeIP_FuncState_HD_BUS* dst) {
  dst->set_timestamp(src.timestamp);
  dst->set_ishdmaphmi(src.IsHDMapHMI);
  dst->set_accstate(src.ACCState);
  dst->set_setspeed(src.SetSpeed);
  dst->set_cpstate(src.CPState);
  dst->set_slaspdlimit(src.SLASpdLimit);
  dst->set_tsitype(src.TSItype);
  dst->set_lanelinecolor(src.LaneLineColor);
  dst->set_lanechangestate(src.LaneChangeState);
  dst->set_lanechangedirection(src.LaneChangeDirection);
  dst->set_currentlinkid(src.CurrentLinkID);
  dst->set_currentlaneno(src.CurrentlaneNo);
  dst->set_destlinkid(src.DestlinkID);
  dst->set_destlaneno(src.DestlaneNo);
  dst->set_destlanecolor(src.DestLaneColor);
  dst->set_issolidline(src.IsSolidLine);
  dst->set_curvatureradius(src.CurvatureRadius);
  dst->set_nocremainingdistance(src.NOCRemainingDistance);
  dst->set_adas_textinfo(src.ADAS_TextInfo);
  dst->set_adas_voice(src.ADAS_Voice);
}

void Struct2Proto_FCM_2_impl(const FCM_2_impl& src, zpilot::VAL::proto::FCM_2_impl* dst) {
  dst->set_hma_status(src.HMA_Status);
  dst->set_hma_highbeamreq(src.HMA_HighbeamReq);
  dst->set_ldw_elk_tja_ldpleftvisuali(src.LDW_ELK_TJA_LDPLeftVisuali);
  dst->set_ldw_elk_tja_ldprightvisuali(src.LDW_ELK_TJA_LDPRightVisuali);
  dst->set_slastate(src.SLAState);
  dst->set_slaspdlimit(src.SLASpdlimit);
  dst->set_slaspdlimitwarning(src.SLASpdlimitWarning);
  dst->set_camera_textinfo(src.Camera_textinfo);
  dst->set_fcm_2_slaspdlimitunits(src.FCM_2_SLASpdlimitUnits);
  dst->set_fcm_2_messagecounter(src.FCM_2_MessageCounter);
  dst->set_fcm_2_crc(src.FCM_2_CRC);
}

void Struct2Proto_FCM_3_impl(const FCM_3_impl& src, zpilot::VAL::proto::FCM_3_impl* dst) {
  dst->set_fcm_3_strngwhlagreq(src.FCM_3_StrngWhlAgReq);
  dst->set_fcm_3_strngwhlagreqactive(src.FCM_3_StrngWhlAgReqActive);
  dst->set_fcm_3_hptcvibreq(src.FCM_3_HptcVibReq);
  dst->set_fcm_3_angctrltrqupprlim(src.FCM_3_AngCtrlTrqUpprLim);
  dst->set_fcm_3_angctrltrqlowrlim(src.FCM_3_AngCtrlTrqLowrLim);
  dst->set_fcm_3_manmachinesharingsts(src.FCM_3_ManMachineSharingSts);
  dst->set_fcm_3_msgcntr(src.FCM_3_MsgCntr);
  dst->set_fcm_3_crc(src.FCM_3_CRC);
}

void Struct2Proto_FCM_5_impl(const FCM_5_impl& src, zpilot::VAL::proto::FCM_5_impl* dst) {
  dst->set_fcm_5_tjaicaexittextinfosts(src.FCM_5_TJAICAExitTextInfoSts);
  dst->set_fcm_5_slaonoffsts(src.FCM_5_SLAONOFFSts);
  dst->set_fcm_5_iesonoffsts(src.FCM_5_IESONOFFSts);
  dst->set_fcm_5_hmaonoffsts(src.FCM_5_HMAONOFFSts);
  dst->set_fcm_5_tsionoffsts(src.FCM_5_TSIONOFFSts);
  dst->set_fcm_5_tlionoffsts(src.FCM_5_TLIONOFFSts);
  dst->set_fcm_5_ldwonoffsts(src.FCM_5_LDWONOFFSts);
  dst->set_fcm_5_warnmodsts(src.FCM_5_WarnModSts);
  dst->set_fcm_5_ldponoffsts(src.FCM_5_LDPONOFFSts);
  dst->set_fcm_5_ldwldpsnvtysts(src.FCM_5_LDWLDPSnvtySts);
  dst->set_fcm_5_elkonoffsts(src.FCM_5_ELKONOFFSts);
  dst->set_slwfonoffsts(src.SLWFONOFFSts);
  dst->set_slaspdlimitwarningaudswsts(src.SLASpdlimitWarningAudSWSts);
  dst->set_fcm_5_speedlmtnmberab(src.FCM_5_SpeedLmtNmberAb);
  dst->set_fcm_5_speedlmtnmbere(src.FCM_5_SpeedLmtNmberE);
  dst->set_fcm_5_slamodeswset(src.FCM_5_SLAmodeSWSet);
  dst->set_fcm_5_resd_1(src.FCM_5_Resd_1);
  dst->set_fcm_5_msgcntr(src.FCM_5_MsgCntr);
  dst->set_fcm_5_crc(src.FCM_5_CRC);
}

void Struct2Proto_FCM_10_impl(const FCM_10_impl& src, zpilot::VAL::proto::FCM_10_impl* dst) {
  dst->set_fcm_10_tsisyssts(src.FCM_10_TSISysSts);
  dst->set_fcm_10_tlisyssts(src.FCM_10_TLISysSts);
  dst->set_fcm_10_tsisgngiway(src.FCM_10_TSISgnGiWay);
  dst->set_fcm_10_tsisgnforb(src.FCM_10_TSISgnForb);
  dst->set_fcm_10_tsisgnlongstaydisp(src.FCM_10_TSISgnLongStayDisp);
  dst->set_fcm_10_tlitrfcli(src.FCM_10_TLITrfcLi);
  dst->set_fcm_10_ldpsyssts(src.FCM_10_LDPSysSts);
  dst->set_fcm_10_ldwsyssts(src.FCM_10_LDWSysSts);
  dst->set_fcm_10_elksyssts(src.FCM_10_ELKSysSts);
  dst->set_fcm_10_tsinoparkwarn(src.FCM_10_TSINoParkWarn);
  dst->set_fcm_10_tjaicatextinfo_resd(src.FCM_10_TJAICATextinfo_Resd);
  dst->set_fcm_10_tjaicaenarcmend_resd(src.FCM_10_TJAICAEnaRcmend_Resd);
  dst->set_fcm_10_ldptjaelktakeoverreq(src.FCM_10_LDPTJAELKTakeoverReq);
  dst->set_fcm_10_tjaicaexittextinfosts(src.FCM_10_TJAICAExitTextInfoSts);
  dst->set_fcm_10_slaonoffsts(src.FCM_10_SLAONOFFSts);
  dst->set_fcm_10_warnmodsts(src.FCM_10_WarnModSts);
  dst->set_fcm_10_elkintvmod(src.FCM_10_ELKIntvMod);
  dst->set_fcm_10_egoleftlineheatgag_resd(src.FCM_10_EgoLeftLineHeatgAg_Resd);
  dst->set_fcm_10_msgcntr(src.FCM_10_MsgCntr);
  dst->set_fcm_10_crc(src.FCM_10_CRC);
}

void Struct2Proto_FCM_FRM_1_impl(const FCM_FRM_1_impl& src, zpilot::VAL::proto::FCM_FRM_1_impl* dst) {
  dst->set_acctaracc(src.ACCTarAcc);
  dst->set_vlcshutdownmode(src.VLCShutdownMode);
  dst->set_accmode_esp(src.ACCMode_ESP);
  dst->set_comfortaccuppervalue(src.ComfortAccUpperValue);
  dst->set_brakepreferred(src.BrakePreferred);
  dst->set_comfortacclowervalue(src.ComfortAccLowerValue);
  dst->set_driveoff(src.DriveOff);
  dst->set_limitaccuppervalue(src.LimitAccUpperValue);
  dst->set_dectostop(src.DecToStop);
  dst->set_limitacclowervalue(src.LimitAccLowerValue);
  dst->set_acc_accecgpovrd(src.ACC_AccECGPOvrd);
  dst->set_hbalevel(src.HBALevel);
  dst->set_hbarequest(src.HBARequest);
  dst->set_prefillrequest(src.PrefillRequest);
  dst->set_fcm_frm_1_messagecounter(src.FCM_FRM_1_MessageCounter);
  dst->set_fcm_frm_1_crc(src.FCM_FRM_1_CRC);
}

void Struct2Proto_FCM_FRM_2_impl(const FCM_FRM_2_impl& src, zpilot::VAL::proto::FCM_FRM_2_impl* dst) {
  dst->set_aebtardec(src.AEBTarDec);
  dst->set_aebdecctrlrequest(src.AEBDecCtrlRequest);
  dst->set_accminimumbraking(src.ACCMinimumBraking);
  dst->set_accstartstopinfo(src.ACCStartStopInfo);
  dst->set_aebreq(src.AEBReq);
  dst->set_fcm_frm_2_reserved1(src.FCM_FRM_2_Reserved1);
  dst->set_awbrequest(src.AWBRequest);
  dst->set_awblevel(src.AWBLevel);
  dst->set_fcm_frm_2_textinfo_info(src.FCM_FRM_2_Textinfo_Info);
  dst->set_fcm_frm_2_reserved2(src.FCM_FRM_2_Reserved2);
  dst->set_fcm_frm_2_messagecounter(src.FCM_FRM_2_MessageCounter);
  dst->set_fcm_frm_2_crc(src.FCM_FRM_2_CRC);
}

void Struct2Proto_FCM_FRM_5_impl(const FCM_FRM_5_impl& src, zpilot::VAL::proto::FCM_FRM_5_impl* dst) {
  dst->set_fcm_frm_5_aebonoffsts(src.FCM_FRM_5_AEBONOFFSts);
  dst->set_fcm_frm_5_fcwsnvtysts(src.FCM_FRM_5_FCWSnvtySts);
  dst->set_fcm_frm_5_fcwonoffsts(src.FCM_FRM_5_FCWONOFFSts);
  dst->set_fcm_frm_5_scfonoffsts(src.FCM_FRM_5_SCFONOFFSts);
  dst->set_fcm_frm_5_daionoffsts(src.FCM_FRM_5_DAIONOFFSts);
  dst->set_fcm_frm_5_resd_1(src.FCM_FRM_5_Resd_1);
  dst->set_fcm_frm_5_msgcntr(src.FCM_FRM_5_MsgCntr);
  dst->set_fcm_frm_5_crc(src.FCM_FRM_5_CRC);
}

void Struct2Proto_FCM_FRM_6_impl(const FCM_FRM_6_impl& src, zpilot::VAL::proto::FCM_FRM_6_impl* dst) {
  dst->set_fcm_frm_6_textinfo_info(src.FCM_FRM_6_Textinfo_Info);
  dst->set_fcm_frm_6_textinfowarn(src.FCM_FRM_6_TextinfoWarn);
  dst->set_fcm_frm_6_timegapseticm(src.FCM_FRM_6_TimeGapSetICM);
  dst->set_fcm_frm_6_scf_popoverreq(src.FCM_FRM_6_SCF_PopoverReq);
  dst->set_fcm_frm_6_scf_spdlimsts(src.FCM_FRM_6_SCF_SpdLimSts);
  dst->set_fcm_frm_6_scf_spdlimunit(src.FCM_FRM_6_SCF_SpdLimUnit);
  dst->set_fcm_frm_6_drvrcfmscfdispfb(src.FCM_FRM_6_DrvrCfmSCFDispFb);
  dst->set_fcm_frm_6_distancewarning(src.FCM_FRM_6_DistanceWarning);
  dst->set_fcm_frm_6_fcw_prewarning(src.FCM_FRM_6_FCW_preWarning);
  dst->set_fcm_frm_6_takeoverreq(src.FCM_FRM_6_TakeOverReq);
  dst->set_fcm_frm_6_fcwmode(src.FCM_FRM_6_FCWMode);
  dst->set_fcm_frm_6_aebmode(src.FCM_FRM_6_AEBMode);
  dst->set_fcm_frm_6_aebdecctrlrequest(src.FCM_FRM_6_AEBDecCtrlRequest);
  dst->set_fcm_frm_6_hmi_indicator(src.FCM_FRM_6_HMI_Indicator);
  dst->set_fcm_frm_6_accmode(src.FCM_FRM_6_ACCMode);
  dst->set_fcm_frm_6_vsetdis(src.FCM_FRM_6_VSetDis);
  dst->set_fcm_frm_6_msgcntr(src.FCM_FRM_6_MsgCntr);
  dst->set_fcm_frm_6_crc(src.FCM_FRM_6_CRC);
}

void Struct2Proto_IDCU_9_impl(const IDCU_9_impl& src, zpilot::VAL::proto::IDCU_9_impl* dst) {
  dst->set_idcu_9_avpremctrlsts(src.IDCU_9_AVPRemCtrlSts);
  dst->set_idcu_9_avpreqlerili(src.IDCU_9_AVPReqLeRiLi);
  dst->set_idcu_9_avpreqhdloli(src.IDCU_9_AVPReqHdLoLi);
  dst->set_idcu_9_avpreqoutdrevimirr(src.IDCU_9_AVPReqOutdReviMirr);
  dst->set_idcu_9_avpreqfourdoorlock(src.IDCU_9_AVPReqfourdoorlock);
  dst->set_idcu_9_avpfailrst(src.IDCU_9_AVPFailrSt);
  dst->set_idcu_9_avpreqwinturndwn(src.IDCU_9_AVPReqWinTurnDwn);
  dst->set_idcu_9_avpreqclssunroof(src.IDCU_9_AVPReqClsSunRoof);
  dst->set_idcu_9_avpreqhorn(src.IDCU_9_AVPReqHorn);
  dst->set_idcu_9_backout(src.IDCU_9_BackOut);
  dst->set_idcu_9_backleftcross(src.IDCU_9_BackLeftCross);
  dst->set_idcu_9_backrightcross(src.IDCU_9_BackRightCross);
  dst->set_idcu_9_avpmatcsts(src.IDCU_9_AVPMatcSts);
  dst->set_idcu_9_avpreqpeps(src.IDCU_9_AVPReqPEPS);
  dst->set_idcu_9_avpfunreq(src.IDCU_9_AVPFunReq);
  dst->set_idcu_9_avpmodreqautoprkg(src.IDCU_9_AVPModReqAutoPrkg);
  dst->set_idcu_9_avpmodreqautoparkout(src.IDCU_9_AVPModReqAutoParkOut);
  dst->set_idcu_9_avpmodreqrmtprkg(src.IDCU_9_AVPModReqRmtPrkg);
  dst->set_idcu_9_avpmodreqrmtparkout(src.IDCU_9_AVPModReqRmtParkOut);
  dst->set_idcu_9_avpmodreqbackforth(src.IDCU_9_AVPModReqBackForth);
  dst->set_read_idcu_9_avpmodreqcruiseprkg(src.Read_IDCU_9_AVPModReqCruisePrkg);
  dst->set_idcu_9_frontout(src.IDCU_9_FrontOut);
  dst->set_idcu_9_avpmodreqmmryprkg(src.IDCU_9_AVPModReqMmryPrkg);
  dst->set_idcu_9_avpmodreqmmryparkout(src.IDCU_9_AVPModReqMmryParkOut);
  dst->set_idcu_9_avpprkgspd(src.IDCU_9_AVPPrkgSpd);
  dst->set_idcu_9_avpprkgslot(src.IDCU_9_AVPPrkgslot);
  dst->set_idcu_9_frontleftcross(src.IDCU_9_FrontLeftCross);
  dst->set_idcu_9_frontleftparallel(src.IDCU_9_FrontLeftParallel);
  dst->set_idcu_9_frontrightcross(src.IDCU_9_FrontRightCross);
  dst->set_idcu_9_frontrightparallel(src.IDCU_9_FrontRightParallel);
  dst->set_idcu_9_parkoutdirectionst(src.IDCU_9_ParkOutDirectionSt);
  dst->set_idcu_9_avprecafailrst(src.IDCU_9_AVPRecaFailrSt);
  dst->set_idcu_9_msgcntr(src.IDCU_9_MsgCntr);
  dst->set_idcu_9_crc(src.IDCU_9_CRC);
}

void Struct2Proto_IDCU_11_impl(const IDCU_11_impl& src, zpilot::VAL::proto::IDCU_11_impl* dst) {
  dst->set_idcu_11_cponoffsts(src.IDCU_11_CPONOFFsts);
  dst->set_idcu_11_noconoffsts(src.IDCU_11_NOCONOFFsts);
  dst->set_idcu_11_alcdrvrcfmonoffsts(src.IDCU_11_ALCDrvrCfmONOFFsts);
  dst->set_idcu_11_alcdrvstysts(src.IDCU_11_ALCDrvStysts);
  dst->set_idcu_11_fctbonoffsts(src.IDCU_11_FCTBONOFFsts);
  dst->set_idcu_11_ppmimod(src.IDCU_11_PPMIMod);
  dst->set_idcu_11_dclconoffsts(src.IDCU_11_DCLCONOFFsts);
  dst->set_idcu_11_prkgintrptvoice(src.IDCU_11_PrkgIntrptVoice);
  dst->set_idcu_11_drvassistylests(src.IDCU_11_DrvAssiStylests);
  dst->set_idcu_11_voicerem(src.IDCU_11_VoiceRem);
  dst->set_idcu_11_hpaonoffsts(src.IDCU_11_HPAONOFFsts);
  dst->set_idcu_1_resd(src.IDCU_1_Resd);
  dst->set_idcu_11_parkingchimevoice(src.IDCU_11_ParkingchimeVoice);
  dst->set_idcu_11_parkintsts(src.IDCU_11_ParkIntSts);
  dst->set_idcu_11_startbuttonsts(src.IDCU_11_StartButtonSts);
  dst->set_idcu_11_resumebuttonsts(src.IDCU_11_ResumeButtonSts);
  dst->set_idcu_11_rpaparkingdrioperateind(src.IDCU_11_RPAParkingDriOperateInd);
  dst->set_idcu_11_parkingprogressbarind(src.IDCU_11_ParkingProgressBarInd);
  dst->set_idcu_11_resd_2(src.IDCU_11_Resd_2);
  dst->set_idcu_11_msgcntr(src.IDCU_11_MsgCntr);
  dst->set_idcu_11_crc(src.IDCU_11_CRC);
}

void Struct2Proto_IDCU_12_impl(const IDCU_12_impl& src, zpilot::VAL::proto::IDCU_12_impl* dst) {
  dst->set_idcu_12rmninfo(src.IDCU_12Rmninfo);
  dst->set_idcu_12_resd_1(src.IDCU_12_Resd_1);
  dst->set_idcu_12cpmod(src.IDCU_12CPMod);
  dst->set_idcu_12fctawarnle(src.IDCU_12FCTAWarnLe);
  dst->set_idcu_12fctawarnri(src.IDCU_12FCTAWarnRi);
  dst->set_idcu_12_rmninfotrig(src.IDCU_12_RmninfoTrig);
  dst->set_idcu_12_resd_2(src.IDCU_12_Resd_2);
  dst->set_idcu_12_msgcntr(src.IDCU_12_MsgCntr);
  dst->set_idcu_12_crc(src.IDCU_12_CRC);
}

void Struct2Proto_IDCU_13_impl(const IDCU_13_impl& src, zpilot::VAL::proto::IDCU_13_impl* dst) {
  dst->set_idcu_aeb_texinfo(src.IDCU_AEB_TexInfo);
  dst->set_idcu_tsr_textinfo(src.IDCU_TSR_TextInfo);
  dst->set_idcu_textinfo_priority(src.IDCU_TextInfo_priority);
  dst->set_idcu_cpmode(src.IDCU_CPMode);
  dst->set_idcu_fctb_texinfo(src.IDCU_FCTB_TexInfo);
  dst->set_idcu_noc_textinfo(src.IDCU_NOC_TextInfo);
  dst->set_idcu_acc_textinfo(src.IDCU_ACC_TextInfo);
  dst->set_idcu_cp_textinfo(src.IDCU_CP_TextInfo);
  dst->set_idcu_dclc_textinfo(src.IDCU_DCLC_TextInfo);
  dst->set_idcu_hwfailure_textinfo(src.IDCU_HWFailure_TextInfo);
  dst->set_idcu_adas_sound(src.IDCU_ADAS_Sound);
  dst->set_idcu_lks_ihc_textinfo(src.IDCU_LKS_IHC_TextInfo);
  dst->set_idcu_adas_voice(src.IDCU_ADAS_Voice);
  dst->set_idcu_13_msgcntr(src.IDCU_13_MsgCntr);
  dst->set_idcu_13_crc(src.IDCU_13_CRC);
}

void Struct2Proto_IDCU_FCM_1_impl(const IDCU_FCM_1_impl& src, zpilot::VAL::proto::IDCU_FCM_1_impl* dst) {
  dst->set_idcu_1_ambli(src.IDCU_1_AmbLi);
  dst->set_idcu_1_hozlposnri(src.IDCU_1_HozlPosnRi);
  dst->set_idcu_1_hozlposnle(src.IDCU_1_HozlPosnLe);
  dst->set_idcu_1_objn1dst(src.IDCU_1_ObjN1Dst);
  dst->set_idcu_1_reserved_1(src.IDCU_1_reserved_1);
  dst->set_idcu_1_objn1_type(src.IDCU_1_ObjN1_Type);
  dst->set_idcu_1_reserved_2(src.IDCU_1_reserved_2);
  dst->set_idcu_1_msgcntr(src.IDCU_1_MsgCntr);
  dst->set_idcu_1_crc(src.IDCU_1_CRC);
}

void Struct2Proto_IDCU_FCM_2_impl(const IDCU_FCM_2_impl& src, zpilot::VAL::proto::IDCU_FCM_2_impl* dst) {
  dst->set_idcu_2_fcmstforadb(src.IDCU_2_FCMStForADB);
  dst->set_idcu_2_reserved_1(src.IDCU_2_reserved_1);
  dst->set_idcu_2_hozlposnri(src.IDCU_2_HozlPosnRi);
  dst->set_idcu_2_hozlposnle(src.IDCU_2_HozlPosnLe);
  dst->set_idcu_2_objn1dst(src.IDCU_2_ObjN1Dst);
  dst->set_idcu_2_reserved_2(src.IDCU_2_reserved_2);
  dst->set_idcu_2_objn2_type(src.IDCU_2_ObjN2_Type);
  dst->set_idcu_2_reserved_3(src.IDCU_2_reserved_3);
  dst->set_idcu_2_msgcntr(src.IDCU_2_MsgCntr);
  dst->set_idcu_2_crc(src.IDCU_2_CRC);
}

void Struct2Proto_IDCU_FCM_3_impl(const IDCU_FCM_3_impl& src, zpilot::VAL::proto::IDCU_FCM_3_impl* dst) {
  dst->set_idcu_3_reserved_1(src.IDCU_3_reserved_1);
  dst->set_idcu_3_hozlposnri(src.IDCU_3_HozlPosnRi);
  dst->set_idcu_3_hozlposnle(src.IDCU_3_HozlPosnLe);
  dst->set_idcu_3_objn3dst(src.IDCU_3_ObjN3Dst);
  dst->set_idcu_3_reserved_2(src.IDCU_3_reserved_2);
  dst->set_idcu_3_objn3_type(src.IDCU_3_ObjN3_Type);
  dst->set_idcu_3_reserved_3(src.IDCU_3_reserved_3);
  dst->set_idcu_3_msgcntr(src.IDCU_3_MsgCntr);
  dst->set_idcu_3_crc(src.IDCU_3_CRC);
}

void Struct2Proto_IDCU_FCM_4_impl(const IDCU_FCM_4_impl& src, zpilot::VAL::proto::IDCU_FCM_4_impl* dst) {
  dst->set_idcu_4_reserved_1(src.IDCU_4_reserved_1);
  dst->set_idcu_4_hozlposnri(src.IDCU_4_HozlPosnRi);
  dst->set_idcu_4_hozlposnle(src.IDCU_4_HozlPosnLe);
  dst->set_idcu_4_objn4dst(src.IDCU_4_ObjN4Dst);
  dst->set_idcu_4_reserved_2(src.IDCU_4_reserved_2);
  dst->set_idcu_4_objn4_type(src.IDCU_4_ObjN4_Type);
  dst->set_idcu_4_reserved_3(src.IDCU_4_reserved_3);
  dst->set_idcu_4_msgcntr(src.IDCU_4_MsgCntr);
  dst->set_idcu_4_crc(src.IDCU_4_CRC);
}

void Struct2Proto_IDCU_FCM_5_impl(const IDCU_FCM_5_impl& src, zpilot::VAL::proto::IDCU_FCM_5_impl* dst) {
  dst->set_idcu_5_reserved_1(src.IDCU_5_reserved_1);
  dst->set_idcu_5_hozlposnri(src.IDCU_5_HozlPosnRi);
  dst->set_idcu_5_hozlposnle(src.IDCU_5_HozlPosnLe);
  dst->set_idcu_5_objn5dst(src.IDCU_5_ObjN5Dst);
  dst->set_idcu_5_reserved_2(src.IDCU_5_reserved_2);
  dst->set_idcu_5_objn5_type(src.IDCU_5_ObjN5_Type);
  dst->set_idcu_5_reserved_3(src.IDCU_5_reserved_3);
  dst->set_idcu_5_msgcntr(src.IDCU_5_MsgCntr);
  dst->set_idcu_5_crc(src.IDCU_5_CRC);
}

void Struct2Proto_IDCU_FCM_6_impl(const IDCU_FCM_6_impl& src, zpilot::VAL::proto::IDCU_FCM_6_impl* dst) {
  dst->set_idcu_6_reserved_1(src.IDCU_6_reserved_1);
  dst->set_idcu_6_hozlposnri(src.IDCU_6_HozlPosnRi);
  dst->set_idcu_6_hozlposnle(src.IDCU_6_HozlPosnLe);
  dst->set_idcu_6_objn6dst(src.IDCU_6_ObjN6Dst);
  dst->set_idcu_6_reserved_2(src.IDCU_6_reserved_2);
  dst->set_idcu_6_objn6_type(src.IDCU_6_ObjN6_Type);
  dst->set_idcu_6_reserved_3(src.IDCU_6_reserved_3);
  dst->set_idcu_6_msgcntr(src.IDCU_6_MsgCntr);
  dst->set_idcu_6_crc(src.IDCU_6_CRC);
}

void Struct2Proto_IDCU_FCM_7_impl(const IDCU_FCM_7_impl& src, zpilot::VAL::proto::IDCU_FCM_7_impl* dst) {
  dst->set_idcu_7_reserved_1(src.IDCU_7_reserved_1);
  dst->set_idcu_7_hozlposnri(src.IDCU_7_HozlPosnRi);
  dst->set_idcu_7_hozlposnle(src.IDCU_7_HozlPosnLe);
  dst->set_idcu_7_objn7dst(src.IDCU_7_ObjN7Dst);
  dst->set_idcu_7_reserved_2(src.IDCU_7_reserved_2);
  dst->set_idcu_7_objn7_type(src.IDCU_7_ObjN7_Type);
  dst->set_idcu_7_reserved_3(src.IDCU_7_reserved_3);
  dst->set_idcu_7_msgcntr(src.IDCU_7_MsgCntr);
  dst->set_idcu_7_crc(src.IDCU_7_CRC);
}

void Struct2Proto_IDCU_FCM_8_impl(const IDCU_FCM_8_impl& src, zpilot::VAL::proto::IDCU_FCM_8_impl* dst) {
  dst->set_idcu_8_reserved_1(src.IDCU_8_reserved_1);
  dst->set_idcu_8_hozlposnri(src.IDCU_8_HozlPosnRi);
  dst->set_idcu_8_hozlposnle(src.IDCU_8_HozlPosnLe);
  dst->set_idcu_8_objn6dst(src.IDCU_8_ObjN6Dst);
  dst->set_idcu_8_reserved_2(src.IDCU_8_reserved_2);
  dst->set_idcu_8_objn8_type(src.IDCU_8_ObjN8_Type);
  dst->set_idcu_8_reserved_3(src.IDCU_8_reserved_3);
  dst->set_idcu_8_msgcntr(src.IDCU_8_MsgCntr);
  dst->set_idcu_8_crc(src.IDCU_8_CRC);
}

void Struct2Proto_VAL_Measurement(const VAL_Measurement& src, zpilot::VAL::proto::VAL_Measurement* dst) {
  dst->set_val_updatecnt(src.VAL_UpdateCnt);
  dst->set_val_version(src.VAL_Version);
  dst->set_vehconfig_code1(src.VehConfig_Code1);
  dst->set_vehconfig_code2(src.VehConfig_Code2);
  Struct2Proto_VAL_DRIVER_SWITCH_BUS(src.SwcOut_VAL_DRIVER_SWITCH, dst->mutable_swcout_val_driver_switch());
  Struct2Proto_VAL_DRIVER_DRIVE_BUS(src.SwcOut_VAL_DRIVER_DRIVE, dst->mutable_swcout_val_driver_drive());
  Struct2Proto_VAL_DRIVER_STATE_BUS(src.SwcOut_VAL_DRIVER_STATE, dst->mutable_swcout_val_driver_state());
  Struct2Proto_VAL_VEHICLE_STATE_BUS(src.SwcOut_VAL_VEHICLE_STATE, dst->mutable_swcout_val_vehicle_state());
  Struct2Proto_VAL_VEHICLE_FUNC_BUS(src.SwcOut_VAL_VEHICLE_FUNC, dst->mutable_swcout_val_vehicle_func());
  Struct2Proto_VAL_VEHICLE_PARTS_BUS(src.SwcOut_VAL_VEHICLE_PARTS, dst->mutable_swcout_val_vehicle_parts());
  Struct2Proto_VAL_ENV_BUS(src.SwcOut_VAL_ENV, dst->mutable_swcout_val_env());
  Struct2Proto_VAL_CONFIG_BUS(src.SwcOut_VAL_CONFIG, dst->mutable_swcout_val_config());
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_VAL_Herbeat_Info, dst->mutable_swcout_val_herbeat_info());
  Struct2Proto_TSR_INIT_BUS(src.SwcOut_VAL_MemGet_TSRInit, dst->mutable_swcout_val_memget_tsrinit());
  dst->set_swcout_val_memget_steerangoffsetinit(src.SwcOut_VAL_MemGet_SteerAngOffsetInit);
  dst->set_swcout_val_memget_timegapinit(src.SwcOut_VAL_MemGet_TimeGapInit);
  dst->set_swcout_val_memget_accstsinit(src.SwcOut_VAL_MemGet_ACCStsInit);
  dst->set_swcout_val_memget_icasstsinit(src.SwcOut_VAL_MemGet_ICASStsInit);
  Struct2Proto_VAL_DRIVER_SWITCH_BUS(src.SwcOut_SysOut_SWITCH_Init, dst->mutable_swcout_sysout_switch_init());
  dst->set_swcout_sysout_steerangoffsetinit(src.SwcOut_SysOut_SteerAngOffsetInit);
  Struct2Proto_TSR_INIT_BUS(src.SwcOut_SysOut_TSRInit, dst->mutable_swcout_sysout_tsrinit());
  dst->set_swcout_sysout_timegapinit(src.SwcOut_SysOut_TimeGapInit);
  dst->set_swcout_sysout_accstsinit(src.SwcOut_SysOut_ACCStsInit);
  dst->set_swcout_sysout_icasstsinit(src.SwcOut_SysOut_ICASStsInit);
  Struct2Proto_SomeIP_ADASDisplayExtend_BUS(src.SwcOut_SysOut_ADASDisplayExtend, dst->mutable_swcout_sysout_adasdisplayextend());
  Struct2Proto_SomeIP_ParkingGenaralInfo_BUS(src.SwcOut_SysOut_ParkingGenaralInfo, dst->mutable_swcout_sysout_parkinggenaralinfo());
  Struct2Proto_SomeIP_FuncState_HD_BUS(src.SwcOut_SysOut_FuncState_HD, dst->mutable_swcout_sysout_funcstate_hd());
  Struct2Proto_FCM_2_impl(src.SwcOut_FCM_2, dst->mutable_swcout_fcm_2());
  Struct2Proto_FCM_3_impl(src.SwcOut_FCM_3, dst->mutable_swcout_fcm_3());
  Struct2Proto_FCM_5_impl(src.SwcOut_FCM_5, dst->mutable_swcout_fcm_5());
  Struct2Proto_FCM_10_impl(src.SwcOut_FCM_10, dst->mutable_swcout_fcm_10());
  Struct2Proto_FCM_FRM_1_impl(src.SwcOut_FCM_FRM_1, dst->mutable_swcout_fcm_frm_1());
  Struct2Proto_FCM_FRM_2_impl(src.SwcOut_FCM_FRM_2, dst->mutable_swcout_fcm_frm_2());
  Struct2Proto_FCM_FRM_5_impl(src.SwcOut_FCM_FRM_5, dst->mutable_swcout_fcm_frm_5());
  Struct2Proto_FCM_FRM_6_impl(src.SwcOut_FCM_FRM_6, dst->mutable_swcout_fcm_frm_6());
  Struct2Proto_IDCU_9_impl(src.SwcOut_IDCU_9, dst->mutable_swcout_idcu_9());
  Struct2Proto_IDCU_11_impl(src.SwcOut_IDCU_11, dst->mutable_swcout_idcu_11());
  Struct2Proto_IDCU_12_impl(src.SwcOut_IDCU_12, dst->mutable_swcout_idcu_12());
  Struct2Proto_IDCU_13_impl(src.SwcOut_IDCU_13, dst->mutable_swcout_idcu_13());
  Struct2Proto_IDCU_FCM_1_impl(src.SwcOut_IDCU_FCM_1, dst->mutable_swcout_idcu_fcm_1());
  Struct2Proto_IDCU_FCM_2_impl(src.SwcOut_IDCU_FCM_2, dst->mutable_swcout_idcu_fcm_2());
  Struct2Proto_IDCU_FCM_3_impl(src.SwcOut_IDCU_FCM_3, dst->mutable_swcout_idcu_fcm_3());
  Struct2Proto_IDCU_FCM_4_impl(src.SwcOut_IDCU_FCM_4, dst->mutable_swcout_idcu_fcm_4());
  Struct2Proto_IDCU_FCM_5_impl(src.SwcOut_IDCU_FCM_5, dst->mutable_swcout_idcu_fcm_5());
  Struct2Proto_IDCU_FCM_6_impl(src.SwcOut_IDCU_FCM_6, dst->mutable_swcout_idcu_fcm_6());
  Struct2Proto_IDCU_FCM_7_impl(src.SwcOut_IDCU_FCM_7, dst->mutable_swcout_idcu_fcm_7());
  Struct2Proto_IDCU_FCM_8_impl(src.SwcOut_IDCU_FCM_8, dst->mutable_swcout_idcu_fcm_8());
  for (const auto& struct_item : src.VAL_reserve) {
      dst->add_val_reserve(struct_item);
   }
}

void Struct2Proto_EVM_TSR_SPL_BUS(const EVM_TSR_SPL_BUS& src, zpilot::RLGS::proto::EVM_TSR_SPL_BUS* dst) {
  dst->set_tsr_giveway(src.TSR_GiveWay);
  dst->set_tsr_longtimedisplay(src.TSR_LongTimeDisplay);
  dst->set_tsr_forbidden(src.TSR_Forbidden);
  dst->set_tsr_spl(src.TSR_SPL);
  dst->set_navstatus(src.NavStatus);
  dst->set_fusion_spl(src.Fusion_SPL);
  dst->set_eleceye_spl(src.ElecEye_SPL);
  dst->set_eleceye_spl_dis(src.ElecEye_SPL_Dis);
  dst->set_map_ramp_dis(src.Map_Ramp_Dis);
  for (const auto& struct_item : src.Map_SPL) {
      dst->add_map_spl(struct_item);
   }
  for (const auto& struct_item : src.Map_SPL_Dis) {
      dst->add_map_spl_dis(struct_item);
   }
  for (const auto& struct_item : src.Map_Ramp_SPL) {
      dst->add_map_ramp_spl(struct_item);
   }
}

void Struct2Proto_ScenarioStep_BUS(const ScenarioStep_BUS& src, zpilot::RLGS::proto::ScenarioStep_BUS* dst) {
  dst->set_main_road_type(src.main_road_type);
  dst->set_sub_road_type(src.sub_road_type);
  dst->set_behavior_road(src.behavior_road);
  dst->set_behavior_lane(src.behavior_lane);
  dst->set_exec_start_dist(src.exec_start_dist);
}

void Struct2Proto_EVM_PILOT_SCEN_BUS(const EVM_PILOT_SCEN_BUS& src, zpilot::RLGS::proto::EVM_PILOT_SCEN_BUS* dst) {
  dst->set_noa_enter_dist_valid(src.noa_enter_dist_valid);
  dst->set_noa_remaining_dist_end_type(src.noa_remaining_dist_end_type);
  dst->set_noa_remaining_dist(src.noa_remaining_dist);
  dst->set_noa_enter_dist(src.noa_enter_dist);
  dst->set_cur_step_id(src.cur_step_id);
  for (const auto& struct_item : src.scenario_vec) {
      Struct2Proto_ScenarioStep_BUS(struct_item, dst->add_scenario_vec());
   }
}

void Struct2Proto_EVM_ROAD_CURVE_BUS(const EVM_ROAD_CURVE_BUS& src, zpilot::RLGS::proto::EVM_ROAD_CURVE_BUS* dst) {
  dst->set_curve_valid_num(src.curve_valid_num);
  for (const auto& struct_item : src.curve_value) {
      dst->add_curve_value(struct_item);
   }
  for (const auto& struct_item : src.curve_dis) {
      dst->add_curve_dis(struct_item);
   }
}

void Struct2Proto_Poly_BUS(const Poly_BUS& src, zpilot::RLGS::proto::Poly_BUS* dst) {
  dst->set_start(src.start);
  dst->set_end(src.end);
  for (const auto& struct_item : src.poly_vec) {
      dst->add_poly_vec(struct_item);
   }
}

void Struct2Proto_Constraint_BUS(const Constraint_BUS& src, zpilot::RLGS::proto::Constraint_BUS* dst) {
  dst->set_constraint_type(src.constraint_type);
  dst->set_constraint_type_ahead(src.constraint_type_ahead);
  dst->set_source_type(src.source_type);
  dst->set_meas_state(src.meas_state);
  dst->set_constraint_type_change_point_dx(src.constraint_type_change_point_dx);
  dst->set_visible_end(src.visible_end);
  dst->set_id(src.id);
  Struct2Proto_Poly_BUS(src.curve, dst->mutable_curve());
}

void Struct2Proto_EVM_ROAD_BUS(const EVM_ROAD_BUS& src, zpilot::RLGS::proto::EVM_ROAD_BUS* dst) {
  Struct2Proto_EVM_ROAD_CURVE_BUS(src.road_curve, dst->mutable_road_curve());
  Struct2Proto_Constraint_BUS(src.left_boundary, dst->mutable_left_boundary());
  Struct2Proto_Constraint_BUS(src.right_boundary, dst->mutable_right_boundary());
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::RLGS::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_EVM_DECS_BUS(const EVM_DECS_BUS& src, zpilot::RLGS::proto::EVM_DECS_BUS* dst) {
  dst->set_host_lane_idx(src.host_lane_idx);
  dst->set_target_lane_idx(src.target_lane_idx);
  dst->set_lc_req(src.lc_req);
  dst->set_lc_req_sync_id(src.lc_req_sync_id);
  dst->set_lc_level(src.lc_level);
  dst->set_lc_req_reason(src.lc_req_reason);
  for (const auto& struct_item : src.lc_lntention_conds) {
      dst->add_lc_lntention_conds(struct_item);
   }
}

void Struct2Proto_Refline_BUS(const Refline_BUS& src, zpilot::RLGS::proto::Refline_BUS* dst) {
  dst->set_ref_source(src.ref_source);
  dst->set_calc_state(src.calc_state);
  dst->set_id(src.id);
  Struct2Proto_Poly_BUS(src.curve, dst->mutable_curve());
}

void Struct2Proto_EVM_LANE_BUS(const EVM_LANE_BUS& src, zpilot::RLGS::proto::EVM_LANE_BUS* dst) {
  dst->set_type(src.type);
  dst->set_lane_source(src.lane_source);
  dst->set_lane_extension_type(src.lane_extension_type);
  dst->set_arrow_dir(src.arrow_dir);
  dst->set_current_width(src.current_width);
  dst->set_end_dist(src.end_dist);
  dst->set_id(src.id);
  Struct2Proto_Constraint_BUS(src.left_constraint, dst->mutable_left_constraint());
  Struct2Proto_Constraint_BUS(src.right_constraint, dst->mutable_right_constraint());
  Struct2Proto_Refline_BUS(src.center_refline, dst->mutable_center_refline());
}

void Struct2Proto_RLGS_Measurement(const RLGS_Measurement& src, zpilot::RLGS::proto::RLGS_Measurement* dst) {
  dst->set_psm_vehinrightmostlane_flag(src.PSM_VehInRightmostLane_Flag);
  dst->set_psm_vehinleftmostlane_flag(src.PSM_VehInLeftmostLane_Flag);
  dst->set_psm_vehinadjacentrightmostlane_flag(src.PSM_VehInAdjacentRightmostLane_Flag);
  dst->set_psm_vehinadjacentleftmostlane_flag(src.PSM_VehInAdjacentLeftmostLane_Flag);
  dst->set_psm_riturnreq(src.PSM_RiTurnReq);
  dst->set_psm_rightsplit(src.PSM_RightSplit);
  dst->set_psm_rightlanechgflag(src.PSM_RightLaneChgFlag);
  dst->set_psm_ramp_rightsplit_instub(src.PSM_Ramp_RightSplit_InStub);
  dst->set_psm_ramp_rightsplit_bfstub(src.PSM_Ramp_RightSplit_BfStub);
  dst->set_psm_ramp_rightsplit(src.PSM_Ramp_RightSplit);
  dst->set_psm_ramp_leftstraight(src.PSM_Ramp_LeftStraight);
  dst->set_psm_ramp_leftmerge_instub(src.PSM_Ramp_LeftMerge_InStub);
  dst->set_psm_ramp_leftmerge_finish(src.PSM_Ramp_LeftMerge_Finish);
  dst->set_psm_ramp_leftmerge(src.PSM_Ramp_LeftMerge);
  dst->set_psm_ramp_cruise(src.PSM_Ramp_Cruise);
  dst->set_psm_noafirsttrigerleftchgflag(src.PSM_NOAFirstTrigerLeftChgFlag);
  dst->set_psm_nextstubisrisplitinhibitleftmergeflag(src.PSM_NextStubIsRiSplitInhibitLeftMergeFlag);
  dst->set_psm_mergeinhibitleftlcoverflag(src.PSM_MergeInhibitLeftLcOverFlag);
  dst->set_psm_leftturnreq(src.PSM_LeftTurnReq);
  dst->set_psm_leftmergeflag(src.PSM_LeftMergeFlag);
  dst->set_psm_leftlanechgflag(src.PSM_LeftLaneChgFlag);
  dst->set_psm_lcovertkcurvelimit(src.PSM_LcOverTkCurveLimit);
  dst->set_psm_lcovertkcondsspdgainle(src.PSM_LcOverTkCondsSpdGainLe);
  dst->set_psm_lcovertkcondspdgainri(src.PSM_LcOverTkCondSpdGainRi);
  dst->set_psm_lcovertk_speedsuppressed(src.PSM_LcOverTk_SpeedSuppressed);
  dst->set_psm_lcovertk_noturnlampreq(src.PSM_LcOverTk_NoTurnLampReq);
  dst->set_psm_lcovertk_nooverride(src.PSM_LcOverTk_NoOverride);
  dst->set_psm_lcovertk_alcswton(src.PSM_LcOverTk_ALCSwtOn);
  dst->set_psm_lcoverinhibitflag(src.PSM_LcOverInhibitFlag);
  dst->set_psm_lanechangetrg(src.PSM_LaneChangeTrg);
  dst->set_psm_isrisplitstubexistflag(src.PSM_IsRiSplitStubExistFlag);
  dst->set_psm_isleftmergestubexistflag(src.PSM_IsLeftMergeStubExistFlag);
  dst->set_psm_hostlaneexitconeflag(src.PSM_HostLaneExitConeFlag);
  dst->set_psm_highway_rightsplit_instub(src.PSM_HighWay_RightSplit_InStub);
  dst->set_psm_highway_rightsplit_bfstub(src.PSM_HighWay_RightSplit_BfStub);
  dst->set_psm_highway_rightsplit(src.PSM_HighWay_RightSplit);
  dst->set_psm_highway_leftstraight(src.PSM_HighWay_LeftStraight);
  dst->set_psm_highway_leftmergefinish(src.PSM_HighWay_LeftMergeFinish);
  dst->set_psm_highway_leftmerge_instub(src.PSM_HighWay_LeftMerge_InStub);
  dst->set_psm_highway_cruise(src.PSM_HighWay_Cruise);
  dst->set_psm_afterleftmergeleftchgflag(src.PSM_AfterLeftMergeLeftChgFlag);
  dst->set_pg_ripathybranchflag(src.PG_RiPathYbranchFlag);
  dst->set_pg_leftpathybranchflag(src.PG_LeftPathYbranchFlag);
  dst->set_pg_curpathybranchflag(src.PG_CurPathYbranchFlag);
  dst->set_rlgs_pg_leftcrossavai_bycone(src.RLGS_PG_LeftCrossAvai_ByCone);
  dst->set_rlgs_pg_ricrossavai_bycone(src.RLGS_PG_RiCrossAvai_ByCone);
  dst->set_psm_ybranchsts(src.PSM_YBranchSts);
  dst->set_psm_riroadclass_out(src.PSM_RiRoadClass_Out);
  dst->set_psm_rampsts(src.PSM_RampSts);
  dst->set_psm_noanavrichgsts(src.PSM_NOANAVRiChgSts);
  dst->set_psm_noanavleftchgsts(src.PSM_NOANAVLeftChgSts);
  dst->set_psm_noafirsttrigerleftchgsts(src.PSM_NOAFirstTrigerLeftChgSts);
  dst->set_psm_noaexitremindbytoll(src.PSM_NOAExitRemindByToll);
  dst->set_psm_noa_lanenumber(src.PSM_NOA_LaneNumber);
  dst->set_psm_afterleftmergeleftchgsts(src.PSM_AfterLeftMergeLeftChgSts);
  dst->set_pg_rmallowrightchangests(src.PG_RMAllowRightChangeSts);
  dst->set_pg_rmallowmovedirsts(src.PG_RMAllowMoveDirSts);
  dst->set_pg_rmallowleftchangests(src.PG_RMAllowLeftChangeSts);
  dst->set_pg_rightlanedirection(src.PG_RightLaneDirection);
  dst->set_pg_pg_splitoperatestatekeep(src.PG_PG_SplitOperateStateKeep);
  dst->set_pg_pg_splitoperatestate(src.PG_PG_SplitOperateState);
  dst->set_pg_leftlanedirection(src.PG_LeftLaneDirection);
  dst->set_pg_controllinecalsource(src.PG_ControlLineCalSource);
  dst->set_pg_centerlanedirection(src.PG_CenterLaneDirection);
  dst->set_rlgs_pg_l1naturests(src.RLGS_PG_L1NatureSts);
  dst->set_rlgs_pg_r1naturests(src.RLGS_PG_R1NatureSts);
  dst->set_rlgs_pg_lanesplitsts(src.RLGS_PG_LaneSplitSts);
  dst->set_pg_roadsemanticssts(src.PG_RoadSemanticsSts);
  dst->set_rlgs_pg_lelinelcavailable(src.RLGS_PG_LeLineLcAvailable);
  dst->set_rlgs_pg_rilinelcavailable(src.RLGS_PG_RiLineLcAvailable);
  dst->set_psm_scenarioclass(src.PSM_ScenarioClass);
  dst->set_psm_scenariotype(src.PSM_ScenarioType);
  dst->set_psm_scenariosubtype(src.PSM_ScenarioSubType);
  dst->set_psm_suggdrvdirection(src.PSM_SuggDrvDirection);
  dst->set_psm_reserve01(src.PSM_reserve01);
  dst->set_psm_reserve02(src.PSM_reserve02);
  dst->set_psm_reserve03(src.PSM_reserve03);
  dst->set_psm_reserve04(src.PSM_reserve04);
  dst->set_psm_reserve05(src.PSM_reserve05);
  dst->set_psm_reserve06(src.PSM_reserve06);
  dst->set_rlgs_version(src.RLGS_Version);
  dst->set_rlgs_psm_lcidrvcondsle(src.RLGS_PSM_LciDrvCondsLe);
  dst->set_rlgs_psm_lcidrvcondsri(src.RLGS_PSM_LciDrvCondsRi);
  dst->set_psm_reserve07(src.PSM_reserve07);
  dst->set_psm_reserve08(src.PSM_reserve08);
  dst->set_psm_reserve09(src.PSM_reserve09);
  dst->set_psm_reserve10(src.PSM_reserve10);
  dst->set_psm_lbshadeinhichgtimeout(src.PSM_LBShadeInhiChgTimeOut);
  dst->set_psm_l2shadeinhichgtimeout(src.PSM_L2ShadeInhiChgTimeOut);
  dst->set_psm_l1shadeinhichgtimeout(src.PSM_L1ShadeInhiChgTimeOut);
  dst->set_psm_hostlaneconeposition_y(src.PSM_HostLaneConePosition_Y);
  dst->set_psm_hostlaneconeposition_x(src.PSM_HostLaneConePosition_X);
  dst->set_psm_forceleftchgtimeout(src.PSM_ForceLeftChgTimeOut);
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_RLGS_Herbeat_Info, dst->mutable_swcout_rlgs_herbeat_info());
  Struct2Proto_EVM_DECS_BUS(src.SwcOut_RLGS_EVM_DECS, dst->mutable_swcout_rlgs_evm_decs());
  for (const auto& struct_item : src.SwcOut_RLGS_EVM_LANE) {
      Struct2Proto_EVM_LANE_BUS(struct_item, dst->add_swcout_rlgs_evm_lane());
   }
  Struct2Proto_EVM_TSR_SPL_BUS(src.SwcOut_RLGS_EVM_TSR_SPL, dst->mutable_swcout_rlgs_evm_tsr_spl());
  Struct2Proto_EVM_PILOT_SCEN_BUS(src.SwcOut_RLGS_EVM_PILOT_SCEN, dst->mutable_swcout_rlgs_evm_pilot_scen());
  Struct2Proto_EVM_ROAD_BUS(src.SwcOut_RLGS_EVM_ROAD, dst->mutable_swcout_rlgs_evm_road());
  dst->set_swcout_rlgs_evm_hmi_info(src.SwcOut_RLGS_EVM_HMI_Info);
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_SM_HEART_BEAT_INFO(const SM_HEART_BEAT_INFO& src, zpilot::VME::proto::SM_HEART_BEAT_INFO* dst) {
  dst->set_swc_id(src.swc_id);
  dst->set_sequence_num(src.sequence_num);
  dst->set_inner_error(src.inner_error);
  dst->set_module_status(src.module_status);
}

void Struct2Proto_VME_Measurement(const VME_Measurement& src, zpilot::VME::proto::VME_Measurement* dst) {
  dst->set_vme_updatecnt(src.VME_UpdateCnt);
  dst->set_vme_version(src.VME_Version);
  Struct2Proto_SM_HEART_BEAT_INFO(src.SwcOut_VME_Herbeat_Info, dst->mutable_swcout_vme_herbeat_info());
  dst->set_swcout_vme_steerangleoffset_deg(src.SwcOut_VME_SteerAngleOffset_deg);
  dst->set_swcout_vme_alpsideslipangle(src.SwcOut_VME_alpSideSlipAngle);
  dst->set_swcout_vme_alpsumslidecurveness(src.SwcOut_VME_alpSumSlideCurveness);
  dst->set_swcout_vme_axrefdt(src.SwcOut_VME_axRefDt);
  dst->set_swcout_vme_axrefms2(src.SwcOut_VME_axRefMs2);
  dst->set_swcout_vme_axvrefms2(src.SwcOut_VME_axvRefMs2);
  dst->set_swcout_vme_axvroadslopems2(src.SwcOut_VME_axvRoadSlopeMs2);
  dst->set_swcout_vme_ayvrefms2(src.SwcOut_VME_ayvRefMs2);
  dst->set_swcout_vme_kaptraj(src.SwcOut_VME_kapTraj);
  dst->set_swcout_vme_psidtopt(src.SwcOut_VME_psiDtOpt);
  dst->set_swcout_vme_rollingbacksts(src.SwcOut_VME_rollingBackSts);
  dst->set_swcout_vme_vxvrefms(src.SwcOut_VME_vxvRefMs);
  dst->set_vme_nvm_get_steerangoffsetinit(src.VME_NvM_Get_SteerAngOffsetInit);
  dst->set_swcout_vme_jerkxms3(src.SwcOut_VME_jerkxMs3);
  dst->set_swcout_vme_jerkyms3(src.SwcOut_VME_jerkyMs3);
  dst->set_timestamp(src.timestamp);
}

void Struct2Proto_J3_TSR_ELEM_BUS(const J3_TSR_ELEM_BUS& src, zpilot::j3_tsr::proto::J3_TSR_ELEM_BUS* dst) {
  dst->set_tsr_approved_flag(src.TSR_Approved_Flag);
  dst->set_tsr_confidence(src.TSR_Confidence);
  dst->set_tsr_filter_type(src.TSR_Filter_Type);
  dst->set_tsr_id(src.TSR_ID);
  dst->set_tsr_relevancy(src.TSR_Relevancy);
  dst->set_tsr_trafficsigntype(src.TSR_TrafficSignType);
  dst->set_sign_position_x(src.Sign_Position_X);
  dst->set_sign_position_y(src.Sign_Position_Y);
  dst->set_sign_position_z(src.Sign_Position_Z);
  dst->set_tsr_internal_id(src.TSR_Internal_ID);
}

void Struct2Proto_J3_TSR_HDR_BUS(const J3_TSR_HDR_BUS& src, zpilot::j3_tsr::proto::J3_TSR_HDR_BUS* dst) {
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_tsrobjectsnumber(src.TSRObjectsNumber);
  dst->set_tsrtypeversion(src.TSRTypeVersion);
  dst->set_rollingcounter_tsrtfl(src.RollingCounter_TSRTFL);
  dst->set_crcchecksum_tsrtfl(src.CRCChecksum_TSRTFL);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_tsr::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_TSR_BUS(const J3_TSR_BUS& src, zpilot::j3_tsr::proto::J3_TSR_BUS* dst) {
  Struct2Proto_J3_SYNC_BUS(src.J3_TSR_SYNC, dst->mutable_j3_tsr_sync());
  Struct2Proto_J3_TSR_HDR_BUS(src.J3_TSR_HDR, dst->mutable_j3_tsr_hdr());
  for (const auto& struct_item : src.J3_TSR_ELEM) {
      Struct2Proto_J3_TSR_ELEM_BUS(struct_item, dst->add_j3_tsr_elem());
   }
}

void Struct2Proto_J3_AEB_HDR_BUS(const J3_AEB_HDR_BUS& src, zpilot::j3_aeb::proto::J3_AEB_HDR_BUS* dst) {
  dst->set_aeb_brake_decel_flag(src.AEB_Brake_Decel_flag);
  dst->set_aeb_ctrl_fusa_invalid(src.AEB_Ctrl_fusa_invalid);
  dst->set_protocolmajorversion(src.ProtocolMajorVersion);
  dst->set_protocolminorversion(src.ProtocolMinorVersion);
  dst->set_rollingcounter_aeb(src.RollingCounter_AEB);
  dst->set_aeb_brake_decel_req(src.AEB_Brake_Decel_Req);
  dst->set_crcchecksum_aeb(src.CRCChecksum_AEB);
}

void Struct2Proto_J3_AEB_LEVEL_BUS(const J3_AEB_LEVEL_BUS& src, zpilot::j3_aeb::proto::J3_AEB_LEVEL_BUS* dst) {
  dst->set_aeb_latentwarn(src.AEB_LatentWarn);
  dst->set_aeb_obj_id_latentwarn(src.AEB_Obj_ID_LatentWarn);
  dst->set_aeb_obj_id_prewarn(src.AEB_Obj_ID_PreWarn);
  dst->set_aeb_obj_type_latentwarn(src.AEB_Obj_Type_LatentWarn);
  dst->set_aeb_obj_type_prewarn(src.AEB_Obj_Type_PreWarn);
  dst->set_aeb_prewarn(src.AEB_PreWarn);
  dst->set_aeb_jerk(src.AEB_Jerk);
  dst->set_aeb_jerk_level(src.AEB_Jerk_Level);
  dst->set_aeb_obj_id_jerk(src.AEB_Obj_ID_Jerk);
  dst->set_aeb_obj_id_prefill(src.AEB_Obj_ID_Prefill);
  dst->set_aeb_obj_type_jerk(src.AEB_Obj_Type_Jerk);
  dst->set_aeb_obj_type_prefill(src.AEB_Obj_Type_Prefill);
  dst->set_aeb_prefill(src.AEB_Prefill);
  dst->set_aeb_fullbrake(src.AEB_FullBrake);
  dst->set_aeb_obj_id_fullbrake(src.AEB_Obj_ID_FullBrake);
  dst->set_aeb_obj_id_partialbrake(src.AEB_Obj_ID_PartialBrake);
  dst->set_aeb_obj_type_fullbrake(src.AEB_Obj_Type_FullBrake);
  dst->set_aeb_obj_type_partialbrake(src.AEB_Obj_Type_PartialBrake);
  dst->set_aeb_partialbrake(src.AEB_PartialBrake);
  dst->set_aeb_eba(src.AEB_EBA);
  dst->set_aeb_hold(src.AEB_Hold);
  dst->set_aeb_obj_id_eba(src.AEB_Obj_ID_EBA);
  dst->set_aeb_obj_id_hold(src.AEB_Obj_ID_Hold);
  dst->set_aeb_obj_type_eba(src.AEB_Obj_Type_EBA);
  dst->set_aeb_obj_type_hold(src.AEB_Obj_Type_Hold);
  dst->set_aeb_hba(src.AEB_HBA);
  dst->set_aeb_hba_level(src.AEB_HBA_Level);
  dst->set_aeb_obj_ttc_latentwarn(src.AEB_Obj_TTC_LatentWarn);
  dst->set_aeb_obj_ttc_prewarn(src.AEB_Obj_TTC_PreWarn);
  dst->set_aeb_obj_ttc_jerk(src.AEB_Obj_TTC_Jerk);
  dst->set_aeb_obj_ttc_prefill(src.AEB_Obj_TTC_Prefill);
  dst->set_aeb_obj_ttc_fullbrake(src.AEB_Obj_TTC_FullBrake);
  dst->set_aeb_obj_ttc_partialbrake(src.AEB_Obj_TTC_PartialBrake);
  dst->set_aeb_obj_ttc_eba(src.AEB_Obj_TTC_EBA);
  dst->set_aeb_obj_ttc_hold(src.AEB_Obj_TTC_Hold);
}

void Struct2Proto_J3_AEB_SUPP_REASON_BUS(const J3_AEB_SUPP_REASON_BUS& src, zpilot::j3_aeb::proto::J3_AEB_SUPP_REASON_BUS* dst) {
  dst->set_aeb_supp_reason(src.AEB_Supp_Reason);
  dst->set_fcw_supp_reason(src.FCW_Supp_Reason);
}

void Struct2Proto_J3_SYNC_BUS(const J3_SYNC_BUS& src, zpilot::j3_aeb::proto::J3_SYNC_BUS* dst) {
  dst->set_frameindex(src.FrameIndex);
  dst->set_imagetimestampms(src.ImageTimestampMs);
  dst->set_spitimestampms(src.SPITimestampMs);
}

void Struct2Proto_J3_AEB_BUS(const J3_AEB_BUS& src, zpilot::j3_aeb::proto::J3_AEB_BUS* dst) {
  Struct2Proto_J3_AEB_HDR_BUS(src.J3_AEB_HDR, dst->mutable_j3_aeb_hdr());
  Struct2Proto_J3_AEB_LEVEL_BUS(src.J3_AEB_LEVEL, dst->mutable_j3_aeb_level());
  Struct2Proto_J3_AEB_SUPP_REASON_BUS(src.J3_AEB_SUPP_REASON, dst->mutable_j3_aeb_supp_reason());
  Struct2Proto_J3_SYNC_BUS(src.J3_AEB_SYNC, dst->mutable_j3_aeb_sync());
}

}
